Software-defined pulse orchestration platform

ABSTRACT

A system comprises pulse program compiler circuitry operable to analyze a pulse program that includes a pulse operation statement, and to generate, based on the pulse program, machine code that, if loaded into a pulse generation and measurement circuit, configures the pulse generation and measurement circuit to generate one or more pulses and/or process one or more received pulses. The pulse operation statement may specify a first pulse to be generated, and a target of the first pulse. The pulse operation statement may specify parameters to be used for processing of a return signal resulting from transmission of the first pulse. The pulse operation statement may specify an expression to be used for processing of the first pulse by the pulse generation and measurement circuit before the pulse generation and measurement circuit sends the first pulse to the target.

PRIORITY CLAIM

This application is a continuation-in-part of U.S. application Ser. No.17/095,944 filed Nov. 12, 2020, which is a continuation of U.S.application Ser. No. 16/777,480 filed Jan. 30, 2020 (U.S. Pat. No.10,958,253), which claims priority to U.S. provisional patentapplication 62/894,905 filed Sep. 2, 2019, now expired. Theaforementioned applications are hereby incorporated herein by referencein their entirety.

BACKGROUND

Limitations and disadvantages of conventional approaches to pulsegeneration systems will become apparent to one of skill in the art,through comparison of such approaches with some aspects of the presentmethod and system set forth in the remainder of this disclosure withreference to the drawings.

BRIEF SUMMARY

Methods and systems are provided for a software-defined pulseorchestration platform, substantially as illustrated by and/or describedin connection with at least one of the figures, as set forth morecompletely in the claims.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows an example pulse orchestration platform.

FIGS. 2A and 2B compare some aspects of classical (binary) computing andquantum computing.

FIG. 2C shows an example use of the pulse orchestration platform forcontrolling a quantum system.

FIG. 3A shows an example quantum orchestration platform (QOP)architecture in accordance with various example implementations of thisdisclosure.

FIG. 3B shows an example implementation of the quantum controllercircuitry of FIG. 3A.

FIG. 4 shows an example implementation of the pulser of FIG. 3B.

FIG. 5 shows an example implementation of the pulse operations managerand pulse operations circuitry of FIG. 3B.

FIG. 6A shows frequency generation circuitry of the quantum controllerof FIG. 3B.

FIG. 6B shows example components of the control signal IF_(l) of FIG.6A.

FIG. 7 shows an example implementation of the digital manager of FIG.3B.

FIG. 8 shows an example implementation of the digital manager of FIG.3B.

FIG. 9A illustrates configuration and control of the quantum controllervia the quantum programming subsystem.

FIG. 9B illustrates an example implementation of the compiler of FIG.9A.

FIGS. 10A-10C show an example quantum machine specification.

FIG. 11 is a flow chart showing an example operation of the QOP.

FIG. 12A shows a portion of a quantum machine configured to perform aPower Rabi calibration.

FIG. 12B shows the result of a Power Rabi calibration.

FIGS. 13A and 13B illustrate the modular and reconfigurable nature ofthe QOP.

DETAILED DESCRIPTION

FIG. 1 shows a pulse orchestration platform. The system comprises aprogramming subsystem 252, a pulse controller 260, and a pulse target258.

The programming subsystem 252 comprises circuitry operable to generatepulse program description 256 which configures the pulse controller 260and includes instructions the pulse controller 260 can execute to carryout the pulse program (i.e., generate the necessary outbound pulse(s)253, process feedback generated in response to the pulse(s) and receivedvia channel 208, and/or process inbound pulses 215) with little or nohuman intervention during runtime. In an example implementation, theprogramming subsystem 252 is a personal computer comprising a processor,memory, and other associated circuitry (e.g., an x86 or x64 chipset)having installed on it a pulse orchestration software development kit(SDK) that enables creation (e.g., by a user via a text editor,integrated development environment (IDE), and/or by automated pulseprogram description generation circuitry) of a high-level (as opposed tobinary or “machine code”) pulse program description 256. In an exampleimplementation, the high-level pulse program description uses ahigh-level programming language (e.g., Python, R, Java, Matlab, etc.)simply as a “host” programming language in which are embedded theprogramming constructs for generating the pulse program description tobe loaded into pulse controller 260.

The high-level pulse program description 256 may comprise aspecification (an example of which is shown in FIGS. 10A-10C) and aprogram (an example program for a Power Rabi calibration is discussedbelow). Although the specification and program may be part of one ormore larger databases and/or contained in one or more files, and one ormore formats, the remainder of this disclosure will, for simplicity ofdescription, assume the configuration data structure and the programdata structure each takes the form of a plain-text file recognizable byan operating system (e.g., windows, Linux, Mac, or another OS) on whichprogramming subsystem 252 runs. The programming subsystem 252 thencompiles the high-level pulse program description 256 to a machine codeversion of the pulse program description 256 (i.e., series of binaryvectors that represent instructions that the hardware of the pulsecontroller 260 can interpret and execute directly).

The programming subsystem 252 communicates with the pulse controller 260using, for example, utilize universal serial bus (USB), peripheralcomponent interconnect (PCIe) bus, wired or wireless Ethernet, or anyother suitable communication protocol. The pulse controller 260comprises circuitry operable to load the machine code pulse programdescription 256 from the programming subsystem 252. Then, execution ofthe machine code by the pulse controller 260 causes the pulse controller260 to generate the corresponding outbound pulse(s) 213 and/or processreturn pulses 215. Depending on the pulse program to be performed,characteristics of generated outbound pulse(s) 213, and/or of processingto be performed on return pulses 215, may be predetermined at designtime and/or may be determined during runtime. The runtime determinationof the outbound pulses characteristics and/or inbound pulse processingmay comprise performance of calculations and processing in the pulsecontroller 260 and/or the programing subsystem 252 during runtime of thepulse program (e.g., runtime analysis of inbound pulses 215 and/orfeedback/results information received from the pulse target 258).

During runtime and/or upon completion of a pulse program performed bythe pulse controller 260, the pulse controller 260 may outputdata/results 208 to the programming subsystem 252. In an exampleimplementation, these results may be used to generate a new pulseprogram description 256 for a subsequent run of the pulse program and/orupdate the pulse program description during runtime.

The pulse controller 260 may comprise a plurality of interconnected, butphysically distinct pulse control modules (e.g., each module being adesktop or rack mounted device) such that pulse control systemsrequiring relatively fewer resources can be realized with relativelyfewer pulse control modules, and pulse control systems requiringrelatively more resources can be realized with relatively more pulsecontrol modules.

The target 258 can be any system with which it is desired to interactvia one or more pulses. One example is where the pulse target 258 is aquantum processor. But of course there are many other types of systemswhere generation and processing of pulses, as enabled by the programmingsubsystem 252 and pulse controller 260, is advantageous.

Another example is where the pulses 213 are radar pulses, the returnpulses 215 are reflections of the pulses 213, and the target 258 is anobject or environment to be characterized based on characteristics ofreflections 215.

Another example is where the pulse target 258 is a device or a systemwhose response to a pulse or series of pulses is to be tested. Forexample, the pulse target 258 may be a wired, wireless, or opticalreceiver and it is desired to test the receiver's response/performancefor various pulses or pulse sequences (e.g., the pulses could berepresentative of desired signals and/or undesired interferers thereceiver may encounter in operation). In this case, the results/feedbackchannel 208 may provide (to the programming subsystem 252 and/or pulsecontroller 260) information about the response/performance of the pulsetarget 258 to the pulse(s) 213, and further pulses/testing may take suchfeedback into account.

For clarity of description, the quantum computing use case is the oneprimarily used in the remainder of this disclosure. But the use ofquantum-specific terminology does not limit the applicability of theconcepts described in this disclosure to other use cases such as theradar and device test use cases described above. For example, referencesto “a quantum element” could be replaced with references to “a target,”references to a “quantum machine specification” could be replaced with“machine specification,” references to a “quantum controller” could bereplaced with references to a “pulse controller”, references to “aquantum programming subsystem” could be replaced with references to a“programming subsystem,” and so on.

Classical computers operate by storing information in the form of binarydigits (“bits”) and processing those bits via binary logic gates. At anygiven time, each bit takes on only one of two discrete values: 0 (or“off”) and 1 (or “on”). The logical operations performed by the binarylogic gates are defined by Boolean algebra and circuit behavior isgoverned by classical physics. In a modern classical system, thecircuits for storing the bits and realizing the logical operations areusually made from electrical wires that can carry two differentvoltages, representing the 0 and 1 of the bit, and transistor-basedlogic gates that perform the Boolean logic operations.

Shown in FIG. 2A is a simple example of a classical computer configuredto a bit 102 and apply a single logic operation 104 to the bit 102. Attime t0 the bit 102 is in a first state, at time t1 the logic operation104 is applied to the bit 102, and at time t2 the bit 102 is in a secondstate determined by the state at time t0 and the logic operation. So,for example, the bit 102 may typically be stored as a voltage (e.g., 1Vdc for a “1” or 0 Vdc for a “0”) which is applied to an input of thelogic operation 104 (comprised of one or more transistors). The outputof the logic gate is then either 1 Vdc or 0 Vdc, depending on the logicoperation performed.

Obviously, a classical computer with a single bit and single logic gateis of limited use, which is why modern classical computers with evenmodest computation power contain billions of bits and transistors. Thatis to say, classical computers that can solve increasingly complexproblems inevitably require increasingly large numbers of bits andtransistors and/or increasingly long amounts of time for carrying outthe algorithms. There are, however, some problems which would require aninfeasibly large number of transistors and/or infeasibly long amount oftime to arrive at a solution. Such problems are referred to asintractable.

Quantum computers operate by storing information in the form of quantumbits (“qubits”) and processing those qubits via quantum gates. Unlike abit which can only be in one state (either 0 or 1) at any given time, aqubit can be in a superposition of the two states at the same time. Moreprecisely, a quantum bit is a system whose state lives in a twodimensional Hilbert space and is therefore described as a linearcombination α|0

+β|1

where |0

and |1

are two basis states, and α and β are complex numbers, usually calledprobability amplitudes, which satisfy |α|²+|β|²=1. Using this notation,when the qubit is measured, it will be 0 with probability |α|² and willbe 1 with probability |β|². |0

and |1

can also be represented by two-dimensional basis vectors

${\begin{bmatrix}1 \\0\end{bmatrix}\mspace{14mu}{{and}\mspace{14mu}\begin{bmatrix}0 \\1\end{bmatrix}}},$

respectively, and then the qubit state is represented by

$\begin{bmatrix}\alpha \\\beta\end{bmatrix}.$

The operations performed by the quantum gates are defined by linearalgebra over Hilbert space and circuit behavior is governed by quantumphysics. This extra richness in the mathematical behavior of qubits andthe operations on them, enables quantum computers to solve some problemsmuch faster than classical computers (in fact some problems that areintractable for classical computers may become trivial for quantumcomputers).

Shown in FIG. 2B is a simple example of a quantum computer configured tostore a qubit 122 and apply a single quantum gate operation 124 to thequbit 122. At time t0 the qubit 122 is described by α₁|0

+β₁|1

, at time t1 the logic operation 104 is applied to the qubit 122, and attime t2 the qubits 122 is described by α₂|0

+β₂|1

.

Unlike a classical bit, a qubit cannot be stored as a single voltagevalue on a wire. Instead, a qubit is physically realized using atwo-level quantum mechanical system. Many physical implementations ofqubits have been proposed and developed over the years with some beingmore promising than others. Some examples of leading qubitsimplementations include superconducting circuits, spin qubits, andtrapped ions.

It is the job of the quantum controller to generate the precise seriesof external signals, usually pulses of electromagnetic waves and pulsesof base band voltage, to perform the desired logic operations (and thuscarry out the desired quantum algorithm). Example implementations of aquantum controller are described in further detail below.

FIG. 2C shows an example use of the pulse orchestration platform forcontrolling a quantum system. For this implementation, the system willbe referred to as a quantum orchestration platform (QOP), the quantumprogramming subsystem 202 corresponds to the programming subsystem 252of FIG. 1, the quantum controller 210 corresponds to the pulsecontroller 210 of FIG. 1, and the quantum processor 218 corresponds tothe target 258 of FIG. 1.

The quantum programming subsystem 202 comprises circuitry operable togenerate a pulse program description 206 which configures the quantumcontroller 210 and includes instructions the quantum controller 210 canexecute to carry out the quantum algorithm (i.e., generate the necessaryoutbound quantum control pulse(s) 213) with little or no humanintervention during runtime.

The quantum programming subsystem 202 is coupled to the quantumcontroller 210 via interconnect 204 which may, for example, utilizeuniversal serial bus (USB), peripheral component interconnect (PCIe)bus, wired or wireless Ethernet, or any other suitable communicationprotocol. The quantum controller 210 comprises circuitry operable toload the machine code pulse program description 206 from the programmingsubsystem 202 via interconnect 204. Then, execution of the machine codeby the quantum controller 210 causes the quantum controller 210 togenerate the necessary outbound quantum control pulse(s) 213 thatcorrespond to the desired operations to be performed on the quantumprocessor 218 (e.g., sent to qubit(s) for manipulating a state of thequbit(s) or to readout resonator(s) for reading the state of thequbit(s), etc.). Depending on the quantum algorithm to be performed,outbound pulse(s) 213 for carrying out the algorithm may bepredetermined at design time and/or may need to be determined duringruntime. The runtime determination of the pulses may compriseperformance of classical calculations and processing in the quantumcontroller 210 and/or the quantum programing subsystem 202 duringruntime of the algorithm (e.g., runtime analysis of inbound pulses 215received from the quantum processor 218).

The quantum controller 210 is coupled to the quantum processor 218 viainterconnect 212 which may comprise, for example, one or more conductorsand/or optical fibers. The quantum controller 210 may comprise aplurality of interconnected, but physically distinct quantum controlmodules (e.g., each module being a desktop or rack mounted device) suchthat quantum control systems requiring relatively fewer resources can berealized with relatively fewer quantum control modules and quantumcontrol systems requiring relatively more resources can be realized withrelatively more quantum control modules.

The quantum processor 218 comprises K (an integer) quantum elements 122,which includes qubits (which could be of any type such assuperconducting, spin qubits, ion trapped, etc.), and, where applicable,any other element(s) for processing quantum information, storing quantuminformation (e.g. storage resonator), and/or coupling the outboundquantum control pulses 213 and inbound quantum control pulses 215between interconnect 212 and the quantum element(s) 122 (e.g., readoutresonator(s)). In an example implementation in which the quantumprocessor comprises readout resonators (or other readout circuitry), Kmay be equal to the total number of qubits plus the number of readoutcircuits. That is, if each of Q (an integer) qubits of the quantumprocessor 218 is associated with a dedicated readout circuit, then K maybe equal to 2Q. For ease of description, the remainder of thisdisclosure will assume such an implementation, but it need not be thecase in all implementations. Other elements of the quantum processor 218may include, for example, flux lines (electronic lines for carryingcurrent), gate electrodes (electrodes for voltage gating),current/voltage lines, amplifiers, classical logic circuits residingon-chip in the quantum processor 218, and/or the like.

FIG. 3A shows an example quantum controller architecture in accordancewith various example implementations of this disclosure. The quantumcontroller 210 comprises L (an integer ≥1) pulser circuits 302 ₀-302_(L−1) and shared circuitry 310.

In the example implementation shown, each pulser circuit 302 _(l) (l aninteger between 0 and L−1) comprises circuitry for exchanginginformation over signal paths 304 _(l), 306 _(l), and 308 _(l), wherethe signal path 308 _(l) carries outbound pulses (e.g., 213 of FIG. 2C)generated by the pulser circuit 302 _(l) (which may be, for example,control pulses sent to the quantum processor 218 to manipulate one ormore properties of one or more quantum elements—e.g., manipulate a stateof one or more qubits, manipulate a frequency of a qubit using fluxbiasing, etc., and/or readout a state of one or more quantum elements),the signal path 306 _(l) carries inbound quantum element readout pulses(e.g., 215 of FIG. 2C) to be processed by the pulser circuit 302 _(l),and signal path 304 _(l) carries control information. Each signal pathmay comprise one or more conductors, optical channels, and/or wirelesschannels.

Each pulser circuit 302 _(l) comprises circuitry operable to generateoutbound pulses on signal path 308 _(l) according to quantum controloperations to be performed on the quantum processor 218. This involvesvery precisely controlling characteristics such as phase, frequency,amplitude, slope, chirp rate, duration, and/or timing of the outboundpulses. The characteristics of an outbound pulse generated at anyparticular time may be determined, at least in part, on inbound pulsesreceived from the quantum processor 218 (via shared circuitry 310 andsignal path 306 _(l)) at a prior time. In an example implementation, thetime required to close the feedback loop (i.e., time from receiving afirst pulse on one or more of paths 315 ₁-315 _(L) (e.g., at an analogto digital converter of the path) to sending a second pulse on one ormore of paths 313 ₀-313 _(L−1) (e.g., at an output of adigital-to-analog converter of the path), where the second pulse isbased on the first pulse, is significantly less than the coherence timeof the qubits of the quantum processor 218. For example, the time toclose the feedback loop may be on the order of 100 nanoseconds. Itshould be noted that each signal path in FIG. 3A may in practice be aset of signal paths for supporting generation of multi-pulse sets (e.g.,two signal paths for two-pulse pairs, three signal paths for three-pulsesets, and so on).

In the example implementation shown, the shared circuitry 310 comprisescircuitry for exchanging information with the pulser circuits 302 ₀-302_(L−1) over signal paths 304 ₀-304 _(L−1), 306 ₀-306 _(L−1), and 308₀-308 _(L−1), where each signal path 308 _(l) carries outbound pulsesgenerated by the pulser circuit 302 _(l), each signal path 306 _(l)carries inbound pulses to be processed by pulser circuit 302 _(l), andeach signal path 304 _(l) carries control information such asflag/status signals, data read from memory, data to be stored in memory,data streamed to/from the quantum programming subsystem 202, and data tobe exchanged between two or more pulsers 302 ₀-302 _(L). Similarly, inthe example shown the shared circuitry 310 comprises circuitry forexchanging information with the quantum processor 218 over signal paths315 ₀-315 _(M−1) and 313 ₁-313 _(K−1), where each signal path 315. (m aninteger between 0 and M−1) carries inbound pulses from the quantumprocessor 218, and each signal path 313 _(k) (k an integer between 0 andK−1) carries outbound pulses to the quantum processor 218. Additionally,in the example shown the shared circuitry 310 comprises circuitry forexchanging information with the quantum programming subsystem oversignal path 311. The shared circuitry 310 may be: integrated with thequantum controller 210 (e.g., residing on one or more of the same fieldprogrammable gate arrays or application specific integrated circuits orprinted circuit boards); external to the quantum controller (e.g., on aseparate FPGA, ASIC, or PCB connected to the quantum controller via oneor more cables, backplanes, or other devices connected to the quantumprocessor 218, etc.); or partially integrated with the quantumcontroller 210 and partially external to the quantum controller 210.

In various implementations, M may be less than, equal to, or greaterthan L, K may be less than, equal to, or greater than L, and M may beless than, equal to, or greater than K. For example, the nature of somequantum algorithms is such that not all K quantum elements need to bedriven at the same time. For such algorithms, L may be less than K andone or more of the L pulsers 302 _(l) may be shared among multiple ofthe K quantum elements circuits. That is, any pulser 302 _(l) maygenerate pulses for different quantum elements at different times. Thisability of a pulser 302 _(l) to generate pulses for different quantumelements at different times can reduce the number of pulsers 302 ₀-302_(L−1) (i.e., reduce L) required to support a given number of quantumelements (thus saving significant resources, cost, size, overhead whenscaling to larger numbers of qubits, etc.).

The ability of a pulser 302 _(l) to generate pulses for differentquantum elements at different times also enables reduced latency. Asjust one example, assume a quantum algorithm which needs to send a pulseto quantum element 122 ₀ at time T1, but whether the pulse is to be of afirst type or second type (e.g., either an X pulse or a Hadamard pulse)cannot be determined until after processing an inbound readout pulse attime T1−DT (i.e., DT time intervals before the pulse is to be output).If there were a fixed assignment of pulsers 302 ₀-302 _(L−1) to quantumelements of the quantum processor 218 (i.e., if 302 ₀ could only sendpulses to quantum element 122 ₀, and pulser 302 ₁ could only send pulsesto quantum element 122 ₁, and so on), then pulser 302 ₀ might not beable to start generating the pulse until it determined what the type wasto be. In the depicted example implementation, on the other hand, pulser302 ₀ can start generating the first type pulse and pulser 302 ₁ canstart generating the second type pulse and then either of the two pulsescan be released as soon as the necessary type is determined. Thus, ifthe time to generate the pulse is T_(lat), in this example the examplequantum controller 210 may reduce latency of outputting the pulse byT_(lat).

The shared circuitry 310 is thus operable to receive pulses via any oneor more of the signals paths 308 ₀-308 _(L−1) and/or 315 ₀-315 _(M−1),process the received pulses as necessary for carrying out a quantumalgorithm, and then output the resulting processed pulses via any one ormore of the signal paths 306 ₀-306 _(L−1) and/or 313 ₀-313 _(K−1). Theprocessing of the pulses may take place in the digital domain and/or theanalog domain. The processing may comprise, for example: frequencytranslation/modulation, phase translation/modulation, frequency and/ortime division multiplexing, time and/or frequency divisiondemultiplexing, amplification, attenuation, filtering in the frequencydomain and/or time domain, time-to-frequency-domain orfrequency-to-time-domain conversion, upsampling, downsampling, and/orany other signal processing operation. At any given time, the decisionas to from which signal path(s) to receive one or more pulse(s), and thedecision as to onto which signal path(s) to output the pulse(s) may be:predetermined (at least in part) in the pulse program description 206;and/or dynamically determined (at least in part) during runtime of thepulse program based on classical programs/computations performed duringruntime, which may involve processing of inbound pulses. As an exampleof predetermined pulse generation and routing, a pulse programdescription 206 may simply specify that a particular pulse withpredetermined characteristics is to be sent to signal path 313 ₁ at apredetermined time. As an example of dynamic pulse determination androuting, a pulse program description 206 may specify that an inboundreadout pulse at time T−DT should be analyzed and its characteristics(e.g., phase, frequency, and/or amplitude) used to determine, forexample, whether at time T pulser 302 _(l) should output a pulse to afirst quantum element or to a second quantum element or to determine,for example, whether at time T pulser 302 _(l) should output a firstpulse to a first quantum element or a second pulse to the first quantumelement. In various implementations of the quantum controller 210, theshared circuitry 310 may perform various other functions instead ofand/or in addition to those described above. In general, the sharedcircuitry 310 may perform functions that are desired to be performedoutside of the individual pulser circuits 302 ₀-302 _(L−1). For example,a function may be desirable to implement in the shared circuitry 310where the same function is needed by a number of pulser circuits from302 ₀-302 _(L−1) and thus may be shared among these pulser circuitsinstead of redundantly being implemented inside each pulser circuit. Asanother example, a function may be desirable to implement in the sharedcircuitry 310 where the function is not needed by all pulser circuits302 ₀-302 _(L−1) at the same time and/or on the same frequency and thusfewer than L circuits for implementing the function may be shared amongthe L pulser circuits 302 ₀-302 _(L−1) through time and/or frequencydivision multiplexing. As another example, a function may be desirableto implement in the shared circuitry 310 where the function involvesmaking decisions based on inputs, outputs, and/or state of multiple ofthe L pulser circuits 302 ₀-302 _(L−1), or other circuits. Utilizing acentralized coordinator/decision maker in the shared circuitry 310 mayhave the benefit(s) of: (1) reducing pinout and complexity of the pulsercircuits 302 ₀-302 _(L−1); and/or (2) reducing decision-making latency.Nevertheless, in some implementations, decisions affecting multiplepulser circuits 302 ₀-302 _(L−1) may be made by one or more of thepulser circuits 302 ₀-302 _(L−1) where the information necessary formaking the decision can be communicated among pulser circuits within asuitable time frame (e.g., still allowing the feedback loop to be closedwithin the qubit coherence time) over a tolerable number of pins/traces.

FIG. 3B shows an example implementation of the quantum controller ofFIG. 2C. The example quantum controller shown comprises pulsers 302₁-302 _(L−1), receive analog frontend 350, input manager 352, digitalmanager 354, pulse operations manager 356, pulse operations 358, outputmanager 360, transmit analog frontend 362, data exchange 364,synchronization manager 366, and input/output (“I/O”) manager 368.Circuitry depicted in FIG. 3B other than pulser circuits 302 ₀-302_(L−1) corresponds to an example implementation of the shared circuitry310 of FIG. 3A.

The receive analog frontend 350 comprises circuitry operable toconcurrently process up to M (an integer ≥1) analog inbound signals(RP′₀-RP′_(M−1)) received via signal paths 315 ₀-315 _(M−1) to generateup to M concurrent inbound signals (RP₀-RP_(M−1)) to be output to inputmanager 352 via one or more signal paths. Although there is shown to beM signals RP and M signals RP′, this need not be the case. Suchprocessing may comprise, for example, analog-to-digital conversion,filtering, upconversion, downconversion, amplification, attenuation,time division multiplexing/demultiplexing, frequency divisionmultiplexing/demultiplexing, and/or the like. In variousimplementations, M may be less than, equal to, or greater than L and Mmay be less than, equal to, or greater than K.

The input manager 352 comprises circuitry operable to route any one ormore of signals (RP₀-RP_(M−1)) to any one or more of pulsers 302 ₀-302_(L−1) (as signal(s) AI₀-AI_(L−1)) and/or to other circuits (e.g. assignal io_mgr to I/O manager 368). In an example implementation, theinput manager 352 comprises one or more switch networks, multiplexers,and/or the like for dynamically reconfiguring which signals RP₀-RP_(M−1)are routed to which pulsers 302 ₀-302 _(L−1). This may enable timedivision multiplexing multiple of the signals RP₀-RP_(M−1) onto a singlesignal AI_(l) and/or time division demultiplexing components (e.g., timeslices) of a signal RP_(m) onto multiple of the signals AI₀-AI_(L−1). Inan example implementation, the input manager 352 comprises one or moremixers and/or filters for frequency division multiplexing multiple ofthe signals RP₀-RP_(M−1) onto a single signal AI_(l) and/or frequencydivision demultiplexing components (e.g., frequency bands) of a signalRP_(m) onto multiple of the signals AI₀-AI_(L−1). The signal routing andmultiplexing/demultiplexing functions performed by the input manager 352enables: a particular pulser 302 _(l) to process different inboundpulses from different quantum elements at different times; a particularpulser 302 _(l) to process different inbound pulses from differentquantum elements at the same time; and multiple of the pulsers 302 ₀-302_(L−1) to processes the same inbound pulse at the same time. In theexample implementation shown, routing of the signals RP₀-RP_(M−1) amongthe inputs of the pulsers 302 ₀-302 _(L−1) is controlled by digitalcontrol signals in_slct₀-in_slct_(L−1) from the pulsers 302 ₀-302_(L−1). In another implementation, the input manager may be operable toautonomously determine the appropriate routing (e.g., where the pulseprogram description 206 includes instructions to be loaded into memoryof, and executed by, the input manager 352). In the exampleimplementation, the input manager 352 is operable to rout input signalsRP₀-RP_(M−1) to the I/O manager 368 (as signal(s) io_mgr), to be sent tothe quantum programing subsystem 202. This routing may, for example, becontrolled by signals from the digital manager 354. In an exampleimplementation, for each input signal RP_(m) there is a digital signal,stream_(m), from the digital manager 354 to the input manager 352 thatcontrols whether RP_(m) will be sent from the input manager 352 to theI/O manager 368 and from there to the quantum programing subsystem 202.

Each of the pulsers 302 ₀-302 _(L−1) is as described above withreference to FIG. 3A. In the example implementation shown, each pulser302 _(l) is operable to generate raw outbound pulses CP′_(l) (“raw” isused simply to denote that the pulse has not yet been processed by pulseoperations circuitry 358) and digital control signals in_slct_(l),D_port_(l), D_(l), out_slct_(l), ops_ctrl_(l), ops_slct_(l), IF_(l),F_(l) and dmod_sclt_(l) for carrying out quantum algorithms on thequantum processor 218, and results_(l) for carrying intermediate and/orfinal results generated by the pulser 302 _(l) to the quantumprogramming subsystem 202. One or more of the pulsers 302 ₀-302 _(L−1)may receive and/or generate additional signals which are not shown inFIG. 3A for clarity of illustration. The raw outbound pulsesCP′₀-CP′_(L−1) are conveyed via signal paths 308 ₀-308 _(L−1) and thedigital control signals are conveyed via signal paths 304 ₀-304 _(L−1).Each of the pulsers 302 _(l) is operable to receive inbound pulse signalAI_(l) and signal f_dmod_(l). Pulser 302 _(l) may process the inboundsignal AI_(l) to determine the state of certain quantum element(s) inthe quantum processor 218 and use this state information for makingdecisions such as, for example, which raw outbound pulse CP′_(l) togenerate next, when to generate it, and what control signals to generateto affect the characteristics of that raw outbound pulse appropriately.Pulser 302 _(l) may use the signal f_dmod_(l) for determining how toprocess inbound pulse signal AI_(l). As an example, when pulser 302 ₁needs to process an inbound signal AI₁ from quantum element 122 ₃, itcan send a dmod_sclt₁ signal that directs pulse operations manager 356to send, on f_dmod₁, settings to be used for demodulation of an inboundsignal AI₁ from quantum element 122 ₃ (e.g., the pulse operationsmanager 356 may send the value cos(ω₃*TS*T_(clk1)+ϕ₃), where ω₃ is thefrequency of quantum element 122 ₃, TS is amount of time passed sincethe reference point, for instance the time at which a pulse programstarted running, and ϕ3 is the phase of the total frame rotation ofquantum element 122 ₃, i.e. the accumulated phase of all frame rotationssince the reference point).

The pulse operations circuitry 358 is operable to process the rawoutbound pulses CP′₀-CP′_(L−1) to generate corresponding output outboundpulses CP₀-CP_(L−1). This may comprise, for example, manipulating theamplitude, phase, duration, chirp rate, slope, and/or frequency of theraw pulse CP′_(l). The pulse operations circuitry 358 receives rawoutbound pulses CP′₀-CP′_(L−1) from pulsers 302 ₀-302 _(L−1), controlsignals ops_cnfg₀-ops_cnfg_(L−1) from pulse operations manager 356, andops_ctrl₀-ops_ctrl_(L−1) from pulsers 302 ₀-302 _(L−1).

The control signal ops_cnfg_(l) configures, at least in part, the pulseoperations circuitry 358 such that each raw outbound pulse CP′_(l) thatpasses through the pulse operations circuitry 358 has performed on itone or more operation(s) tailored for that particular pulse. Toillustrate, denoting a raw outbound pulse from pulser 302 ₃ at time T1as CP′_(3,T1), then, at time T1 (or sometime before T1 to allow forlatency, circuit setup, etc.), the digital control signal ops_cnfg₃(denoted ops_cnfg_(3,T1) for purposes of this example) provides theinformation (e.g., in the form of one or more matrix, as describedbelow) as to what specific operations are to be performed on pulseCP′_(3,T1). Similarly, ops_cnfg_(4,T1) provides the information as towhat specific operations are to be performed on pulse CP′_(4,T1), andops_cnfg_(3,T2) provides the information as to what specific operationsare to be performed on pulse CP′_(4,T1).

The control signal ops_ctrl_(l) provides another way for the pulser 302_(l) to configure how any particular pulse is processed in the pulseoperations circuitry 358. This may enable the pulser 302 _(l) to, forexample, provide information to the pulse operation circuitry 358 thatdoes not need to pass through the pulse operation manager 356. Forexample, the pulser 302 _(l) may send matrix values calculated inreal-time by the pulser 302 _(l) to be used by the pulse operationcircuitry 358 to modify pulse CP′_(l). These matrix values arrive to thepulse operation circuitry 358 directly from the pulser 302 _(l) and donot need to be sent to the pulse operation manager first. Anotherexample may be that the pulser 302 _(l) provides information to thepulse operation circuitry 358 to affect the operations themselves (e.g.the signal ops_ctrl_(l) can choose among several different mathematicaloperations that can be performed on the pulse).

The pulse operations manager 356 comprises circuitry operable toconfigure the pulse operations circuitry 358 such that the pulseoperations applied to each raw outbound pulse CP′_(l) are tailored tothat particular raw outbound pulse. To illustrate, denoting a first rawoutbound pulse to be output during a first time interval T1 asCP′_(l,T1), and a second raw outbound pulse to be output during a secondtime interval T2 as CP′_(l,T2), then pulse operations circuitry 358 isoperable to perform a first one or more operations on CP′_(l,T1) and asecond one or more operations on CP′_(1,T2). The first one or moreoperations may be determined, at least in part, based on to whichquantum element the pulse CP_(1,T1) is to be sent, and the second one ormore operations may be determined, at least in part, based on to whichquantum element the pulse CP_(1,T2) is to be sent. The determination ofthe first one or more operations and second one or more operations maybe performed dynamically during runtime.

The transmit analog frontend 362 comprises circuitry operable toconcurrently process up to K digital signals DO_(k) to generate up to Kconcurrent analog signals AO_(k) to be output to the quantum processor218. Such processing may comprise, for example, digital-to-analogconversion, filtering, upconversion, downconversion, amplification,attenuation, time division multiplexing/demultiplexing, frequencydivision multiplexing/demultiplexing and/or the like. In an exampleimplementation, each of the one or more of signal paths 313 ₀-313 _(K−1)(FIG. 3A) represents a respective portion of Tx analog frontend circuit362 as well as a respective portion of interconnect 212 (FIG. 2C)between the Tx analog frontend circuit 362 and the quantum processor218. Although there is one-to-one correspondence between the number ofDO signals and the number of AO signals in the example implementationdescribed here, such does not need to be the case. In another exampleimplementation, the analog frontend 362 is operable to map more (orfewer) signals DO to fewer (or more) signals AO. In an exampleimplementation the transmit analog frontend 362 is operable to processdigital signals DO₀-DO_(K−1) as K independent outbound pulses, as K/2two-pulse pairs, or process some of signals DO₀-DO_(K−1) as independentoutbound pulses and some signals DO₀-DO_(K−1) as two-pulse pairs (atdifferent times and/or concurrently.

The output manager 360 comprises circuitry operable to route any one ormore of signals CP₀-CP_(L−1) to any one or more of signal paths 313₀-313 _(K−1). As just one possible example, signal path 313 ₀ maycomprise a first path through the analog frontend 362 (e.g., a firstmixer and DAC) that outputs AO₀ and traces/wires of interconnect 212that carry signal AO₀; signal path 313 ₁ may comprise a second paththrough the analog frontend 362 (e.g., a second mixer and DAC) thatoutputs AO₁ and traces/wires of interconnect 212 that carry signal AO₁,and so on. In an example implementation, the output manager 360comprises one or more switch networks, multiplexers, and/or the like fordynamically reconfiguring which one or more signals CP₀-CP_(L−1) arerouted to which signal paths 313 ₀-313 _(K−1). This may enable timedivision multiplexing multiple of the signals CP₀-CP_(L−1) onto a singlesignal path 313 _(k) and/or time division demultiplexing components(e.g., time slices) of a signal CP_(m) onto multiple of the signal paths313 ₀-313 _(k−1). In an example implementation, the output manager 360comprises one or more mixers and/or filters for frequency divisionmultiplexing multiple of the signals CP₀-CP_(M−1) onto a single signalpath 313 _(k) and/or frequency division demultiplexing components (e.g.,frequency bands) of a signal CP_(m) onto multiple of the signal paths313 ₀-313 _(K−1). The signal routing and multiplexing/demultiplexingfunctions performed by the output manager 360 enables: routing outboundpulses from a particular pulser 302 _(l) to different ones of the signalpaths 313 ₀-313 _(K−1) at different times; routing outbound pulses froma particular pulser 302 _(l) to multiple of the signal paths 313 ₀-313_(K−1) at the same time; and multiple of the pulsers 302 ₀-302 _(L−1)generating pulses for the same signal path 313 _(k) at the same time. Inthe example implementation shown, routing of the signals CP₀-CP_(L−1)among the signal paths 313 ₀-313 _(K−1) is controlled by digital controlsignals out_slct₀-out_slct_(L−1) from the pulsers 302 ₀-302 _(L−1). Inanother implementation, the output manager 360 may be operable toautonomously determine the appropriate routing (e.g., where the quantumpulse program description 206 includes instructions to be loaded intomemory of, and executed by, the output manager 360). In an exampleimplementation, at any given time, the output manager 360 is operable toconcurrently route K of the digital signals CP₀-CP_(L−1) as Kindependent outbound pulses, concurrently route K/2 of the digitalsignals CP₀-CP_(L−1) as two-pulse pairs, or route some of signalsCP₀-CP_(L−1) as independent outbound pulses and some others of thesignals CP₀-CP_(L−1) as multi-pulse sets (at different times and/orconcurrently).

The digital manager 354 comprises circuitry operable to process and/orroute digital control signals (DigCtrl₀-DigCtrl_(J−1)) to variouscircuits of the quantum controller 210 and/or external circuits coupledto the quantum controller 210. In the example implementation shown, thedigital manager receives, from each pulser 302 _(l), (e.g., via one ormore of signal paths 304 ₀-304 _(N−1)) a digital signal Di that is to beprocessed and routed by the digital manager 354, and a control signalD_port_(l) that indicates to which output port(s) of the digital manager354 the signal D_(l) should be routed. The digital control signals maybe routed to, for example, any one or more of circuits shown in FIG. 3B,switches/gates which connect and disconnect the outputs AO₀-AO_(K−1)from the quantum processor 218, external circuits coupled to the quantumcontroller 210 such as microwave mixers and amplifiers, and/or any othercircuitry which can benefit from on real-time information from thepulser circuits 302 ₀-302 _(L−1). Each such destination of the digitalsignals may require different operations to be performed on the digitalsignal (such as delay, broadening, or digital convolution with a givendigital pattern). These operations may be performed by the digitalmanager 354 and may be specified by control signals from the pulsers 302₀-302 _(L−1). This allows each pulser 302 _(l) to generate digitalsignals to different destinations and allows different ones of pulsers302 ₀-302 _(L−1) to generate digital signals to the same destinationwhile saving resources.

The synchronization manager 366 comprises circuitry operable to managesynchronization of the various circuits shown in FIG. 3B. Suchsynchronization is advantageous in a modular and dynamic system, such asquantum controller 210, where different ones of pulsers 302 ₀-302 _(L−1)generate, receive, and process pulses to and from different quantumelements at different times. For example, while carrying out a quantumalgorithm, a first pulser circuit 302 ₁ and a second pulser circuit 302₂ may sometimes need to transmit pulses at precisely the same time andat other times transmit pulses independently of one another. In theexample implementation shown, the synchronization manager 366 reducesthe overhead involved in performing such synchronization.

The data exchange circuitry 364 is operable to manage exchange of dataamong the various circuits shown in FIG. 3B. For example, while carryingout a quantum algorithm, a first pulser circuit 302 ₁ and a secondpulser circuit 302 ₂ may sometimes need to exchange information. As justone example, pulser 302 ₁ may need to share, with pulser 302 ₂, thecharacteristics of an inbound signal AI₁ that it just processed so thatpulser 302 ₂ can generate a raw outbound pulse CP′₂ based on thecharacteristics of AI₁. The data exchange circuitry 364 may enable suchinformation exchange. In an example implementation, the data exchangecircuitry 364 may comprise one or more registers to and from which thepulsers 302 ₀-302 _(L−1) can read and write.

The I/O manager 368 is operable to route information between the quantumcontroller 210 and the quantum programming subsystem 202. Machine codequantum pulse program descriptions may be received via the I/O manager368. Accordingly, the I/O manager 368 may comprise circuitry for loadingthe machine code into the necessary registers/memory (including anySRAM, DRAM, FPGA BRAM, flash memory, programmable read only memory,etc.) of the quantum controller 210 as well as for reading contents ofthe registers/memory of the quantum controller 210 and conveying thecontents to the quantum programming subsystem 202. The I/O manager 368may, for example, include a PCIe controller, AXIcontroller/interconnect, and/or the like. In an example implementation,the I/O manager 368 comprises one or more registers 380 which can bewritten to and read from via a quantum machine API (an example of whichis shown below in Table 6) and via reserved variables in the languageused to create pulse program description 206.

FIG. 4 shows an example implementation of the pulser of FIG. 3B. Theexample pulser 302 _(l) shown comprises instruction memory 402, pulsetemplate memory 404, digital pattern memory 406, control circuitry 408,and compute and/or signal processing circuitry (CSP) 410.

The memories 402, 404, 406 may comprise one or more be any type ofsuitable storage elements (e.g., DRAM, SRAM, Flash, etc.). Theinstructions stored in memory 402 are instructions to be executed out bythe pulser 302 _(l) for carrying out its role in a quantum algorithm.Because different pulsers 302 ₀-302 _(L−1) have different roles to playin any particular quantum algorithm (e.g., generating different pulsesat different times), the instructions memory 402 for each pulser 302_(l) may be specific to that pulser. For example, the pulse programdescription 206 from the quantum programming subsystem 202 may comprisea first set of instructions to be loaded (via I/O manager 368) intopulser 302 ₀, a second set of instructions to be loaded into pulser 302_(l), and so on. Each pulse template stored in memory 404 comprises asequence of one or more samples of any arbitrary shape (e.g., Gaussian,sinc, impulse, etc.) representing the pulses to be sent to pulseoperation circuitry 358. Each digital pattern stored in memory 406comprises a sequence of one or more binary values which may representthe digital pulses to be sent to the digital manager 354 for generatingdigital control signals DigCtrl₀-DigCtrl_(J−1).

The control circuitry 408 is operable to execute the instructions storedin memory 402 to process inbound signal AI_(l), generate raw outboundpulses CP′_(l), and generate digital control signals in_slct_(l),out_slct_(l), D_port_(l), D_(l), IF_(l), F_(l), ops_slct_(l),ops_ctrl_(l), results_(l), dmod_slct_(l) and pair_(l). In the exampleimplementation shown, the processing of the inbound signal AI_(l) isperformed by the CSP circuitry 410 and based (at least in part) on thesignal f_dmod_(l).

The compute and/or signal processing circuitry (CSP) 410 is operable toperform computational and/or signal processing functions, which maycomprise, for example Boolean-algebra based logic and arithmeticfunctions and demodulation (e.g., of inbound signals AI_(l)). The CSP410 may comprise memory in which are stored instructions for performingthe functions and demodulation. The instructions may be specific to aquantum algorithm to be performed and be generated during compilation ofa quantum machine specification and QUA program.

In operation of an example implementation, generation of a raw outboundpulse CP′_(l) comprises the control circuitry 408: (1) determining apulse template to retrieve from memory 404 (e.g., based on a result ofcomputations and/or signal processing performed by the CSP 410); (2)retrieving the pulse template; (3) performing some preliminaryprocessing on the pulse template; (4) determining the values of F, IF,pair_(l), ops_slct_(l), and dmod_slct_(l) to be sent to the pulseoperation manager 356 (as predetermined in the pulse program description206 and/or determined dynamically based on results of computationsand/or signal processing performed by the CSP 410); (5) determining thevalue of ops_ctrl_(l) to be sent to the pulse operation circuitry 358;(6) determining the value of in_slct_(l) to be sent to the input manager352; (7) determining a digital pattern to retrieve from memory 406 (aspredetermined in the pulse program description 206 and/or determineddynamically based on results of computations and/or signal processingperformed by the CSP 410); (8) outputting the digital pattern as Di tothe digital manager along with control signal D_port_(l) (aspredetermined in the pulse program description and/or determineddynamically based on results of computations and/or signal processingperformed by the CSP 410); (9) outputting the raw outbound pulse CP′_(l)to the pulse operations circuitry 358; (10) outputting results_(l) tothe I/O manager.

FIG. 5 shows an example implementation of the pulse operations managerand pulse operations circuitry of FIG. 3B. The pulse operationscircuitry 358 comprises a plurality of pulse modification circuits 508₀-508 _(R−1) (R is an integer ≥1 in general, and R=L/2 in the exampleshown). The pulse operations manager 356 comprises control circuitry502, routing circuitry 506, and a plurality of modification settingscircuits 504 ₀-504 _(K−1).

Although the example implementation has a 1-to-2 correspondence betweenpulse modification circuits 508 ₀-508 _(R−1) and pulser circuits 302₀-302 _(L−1), such does not need to be the case. In otherimplementations there may be fewer pulse modification circuits 508 thanpulser circuits 302. Similarly, other implementations may comprise morepulse modification circuits 508 than pulser circuits 302.

As an example, in some instances, two of the pulsers 302 ₀-302 _(L−1)may generate two raw outbound pulses which are a phase-quadrature pulsepair. For example, assuming CP₁ and CP₂ are a phase-quadrature pulsepair to be output on path 313 ₃. In this example, pulse operationscircuitry 358 may process CP₁ and CP₂ by multiplying a vectorrepresentation of CP′₁ and CP′₂ by one or more 2 by 2 matrices to: (1)perform single-sideband-modulation, as given by

${\begin{pmatrix}{CP_{1}} \\{CP_{2}}\end{pmatrix} = {\begin{pmatrix}{\cos\left( {\omega*TS*T_{clck1}} \right)} & {{- s}{{in}\left( {\omega*TS*T_{clck1}} \right)}} \\{\sin\left( {\omega*TS*T_{clck1}} \right)} & {\cos\left( {\omega*TS*T_{clck1}} \right)}\end{pmatrix}\begin{pmatrix}{CP}_{1}^{\prime} \\{CP}_{2}^{\prime}\end{pmatrix}}},$

where ω is the frequency of the single side band modulation and TS isthe time passed since the reference time (e.g. the beginning of acertain control protocol); (2) keep track of frame-of-referencerotations, as given by

${\begin{pmatrix}{CP_{1}} \\{CP_{2}}\end{pmatrix} = {\begin{pmatrix}{\cos(\phi)} & {- {\sin(\phi)}} \\{\sin(\phi)} & {\cos(\phi)}\end{pmatrix}\begin{pmatrix}{CP}_{1}^{\prime} \\{CP}_{2}^{\prime}\end{pmatrix}}},$

where ϕ is the total phase that the frame of reference accumulated sincethe reference time; and/or (3) perform an IQ-mixer correction

${\begin{pmatrix}{CP_{1}} \\{CP_{2}}\end{pmatrix} = {\begin{pmatrix}C_{00} & C_{01} \\C_{10} & C_{11}\end{pmatrix}\begin{pmatrix}{CP}_{1}^{\prime} \\{CP}_{2}^{\prime}\end{pmatrix}}},$

where C₀₀, C₀₁, C₁₀, and C₁₁ are the elements of a matrix that correctsfor IQ-mixer imperfections. In an example implementation, eachmodification settings circuit, 504 _(k), contains registers that containthe matrix elements of three matrices:

${C_{k} = \begin{pmatrix}C_{k00} & C_{k01} \\C_{k10} & C_{k11}\end{pmatrix}},$

an IQ-mixer correction matrix;

${S_{k} = \begin{pmatrix}{\cos\left( {\omega_{k}*TS*T_{clck1}} \right)} & {{- s}{{in}\left( {\omega_{k}*TS} \right)}*T_{clck1}} \\{\sin\left( {\omega_{k}*TS*T_{clck1}} \right)} & {\cos\left( {\omega_{k}*TS*T_{clckl}} \right)}\end{pmatrix}},$

a single side band frequency modulation matrix; and

${F_{k} = \begin{pmatrix}{\cos\left( \phi_{k} \right)} & {{- s}{{in}\left( \phi_{k} \right)}} \\{\sin\left( \phi_{k} \right)} & {\cos\left( \phi_{k} \right)}\end{pmatrix}},$

a frame rotation matrix, which rotates the IQ axes around the axisperpendicular to the IQ plane (i.e. the z-axis if I and Q are the x-axisand y-axis). In an example implementation, each modification settingscircuit 504 _(k) also contains registers that contain the elements ofthe matrix products C_(k)S_(k)F_(k) and S_(k)F_(k).

In the example shown, each pulse modification circuit 508 _(r) isoperable to process two raw outbound pulses CP′_(2r) and CP′_(2r+1)according to: the modification settings ops_cnfg_(2r) andops_cnfg_(2r+1); the signals ops_ctrl_(2r) and ops_ctrl_(2r+1); and thesignals pair_(2r) and pair_(2r+1). In an example implementationpair_(2r) and pair_(2r+1) may be communicated as ops_ctrl_(2r) andops_ctrl_(2r+1). The result of the processing is outbound pulses CP_(2r)and CP_(2r+1). Such processing may comprise adjusting a phase,frequency, and/or amplitude of the raw outbound pulses CP′_(2r) andCP′_(2r+1). In an example implementation, ops_cnfg_(2r) andops_cnfg_(2r+1) are in the form of a matrix comprising real and/orcomplex numbers and the processing comprises matrix multiplicationinvolving a matrix representation of the raw outbound pulses CP_(2r) andCP_(2r+1) and the ops_cnfg_(2r) and ops_cnfg_(2r+1) matrix.

The control circuitry 502 is operable to exchange information with thepulser circuits 302 ₀-302 _(L−1) to generate values ofops_confg₀-ops_confg_(L−1) and f_demod₀-f_demod_(L−1), to controlrouting circuitry 506 based on signals ops_slct₀-ops_slct_(L−1) anddmod_slct₀-dmod_slct_(L−1), and to update pulse modification settings504 ₀-504 _(K−1) based on IF₀-IF_(L−1) and F₀-F_(L−1) such that pulsemodification settings output to pulse operations circuitry 358 arespecifically tailored to each raw outbound pulse (e.g., to which quantumelement 222 the pulse is destined, to which signal path 313 the pulse isdestined, etc.) to be processed by pulse operations circuitry 358.

Each modification settings circuit 504 _(k) comprises circuitry operableto store modification settings for later retrieval and communication tothe pulse operations circuitry 358. The modification settings stored ineach modification settings circuit 504 _(k) may be in the form of one ormore two-dimensional complex-valued matrices. Each signal path 313 ₀-313_(K−1) may have particular characteristics (e.g., non-idealities ofinterconnect, mixers, switches, attenuators, amplifiers, and/or circuitsalong the paths) to be accounted for by the pulse modificationoperations. Similarly, each quantum element 122 ₀-122 _(k) may have aparticular characteristics (e.g. resonance frequency, frame ofreference, etc.). In an example implementation, the number of pulsemodification settings, K, stored in the circuits 504 corresponds to thenumber of quantum element 122 ₀-122 _(K−1) and of signal paths 313 ₀-313_(K−1) such that each of the modification settings circuits 504 ₀-504_(K−1) stores modification settings for a respective one of the quantumelements 122 ₀-122 _(K−1) and/or paths 313 ₀-313 _(K−1). In otherimplementations, there may be more or fewer pulse modification circuits504 than signal paths 313 and more or fewer pulse modification circuits504 than quantum elements 122 and more or fewer signal paths 313 thanquantum elements 122. The control circuitry 502 may load values into themodification settings circuit 504 ₀-504 _(K−1) via signal 503.

The routing circuitry 506 is operable to route modification settingsfrom the modification settings circuits 504 ₀-504 _(L−1) to the pulseoperations circuit 358 (as ops_confg₀-ops_confg_(L−1)) and to thepulsers 302 ₀-302 _(L−1) (as f_dmod₀-f_dmod_(L−1)). In the exampleimplementation shown, which of the modification settings circuits 504₀-504 _(K−1) has its/their contents sent to which of the pulsemodification circuits 508 ₀-508 _(R−1) and to which of the pulsers 302₀-302 _(L−1) is controlled by the signal 505 from the control circuitry502.

The signal ops_slct_(l) informs the pulse operations manager 356 as towhich modification settings 504 _(k) to send to the pulse modificationcircuit 508 _(l). The pulser 302 _(l) may determine ops_slct_(l) basedon the particular quantum element 122 _(k) and/or signal path 313 _(k)to which the pulse is to be transmitted (e.g., the resonant frequency ofthe quantum element, frame of reference, and/or mixer correction). Thedetermination of which quantum element and/or signal path to which aparticular pulser 302 _(l) is to send an outbound pulse at a particulartime may be predetermined in the pulse program description 206 or may bedetermined based on calculations performed by the pulser 302 _(l) and/orothers of the pulsers 302 ₀-302 _(L−1) during runtime. The controlcircuitry 502 may then use this information to configure the routingblock 506 such that the correct modification settings are routed to thecorrect one or more of the pulse modification circuits 508 ₀-508 _(L−1).

In an example implementation, the digital signal IF_(l) instructs thepulse operations manager 356 to update a frequency setting of themodification settings circuit 504 _(k) indicated by ops_slct_(l). In anexample implementation, the frequency setting is the matrix S_(k)(described above) and the signal IF_(l) carries new values indicatingthe new ω_(k) to be used in the elements of the matrix S_(k). The newvalues may, for example, be determined during a calibration routine(e.g., performed as an initial portion of the quantum algorithm) inwhich one or more of the pulsers 302 ₀-302 _(L−1) sends a series ofoutbound pulses CP, each at a different carrier frequency, and thenmeasures the corresponding inbound signals AI.

In an example implementation, the signal F_(l) instructs the pulseoperations manager 356 to update a frame setting of the modificationsettings circuit 504 _(k) indicated by ops_slct_(l). In an exampleimplementation, the frame setting is the matrix F_(k) (described above)and the signal F_(l) carries a rotation matrix F_(l) which multiplieswith F_(k) to rotate F_(k). This can be written as

${F_{k} = {{F_{1}F_{k}} = {{\begin{pmatrix}{\cos({\Delta\phi})} & {- {\sin({\Delta\phi})}} \\{\sin({\Delta\phi})} & {\cos({\Delta\phi})}\end{pmatrix}\begin{pmatrix}{\cos\left( \phi_{k} \right)} & {- {\sin\left( \phi_{k} \right)}} \\{\sin\left( \phi_{k} \right)} & {\cos\left( \phi_{k} \right)}\end{pmatrix}} = \begin{pmatrix}{\cos\left( {\phi_{k} + {\Delta\phi}} \right)} & {- {\sin\left( {\phi_{k} + {\Delta\phi}} \right)}} \\{\sin\left( {\phi_{k} + {\Delta\phi}} \right)} & {\cos\left( {\phi_{k} + {\Delta\phi}} \right)}\end{pmatrix}}}},$

where ϕ_(k) is the frame of reference before the rotation and Δϕ is theamount by which to rotate the frame of reference. The pulser 302 _(l)may determine Δϕ based on a predetermined algorithm or based oncalculations performed by the pulsers 302 _(l) and/or others of thepulsers 302 ₀-302 _(L−1) during runtime.

In an example implementation, the signal dmod_sclt_(l) informs the pulseoperations manager 356 from which of the modification settings circuits504 _(k) to retrieve values to be sent to pulser 302 _(l) as f_dmod_(l).The pulser 302 _(l) may determine dmod_slct_(l) based on the particularquantum element 122 _(k) and/or signal path 315 _(k) from which thepulse to be processed arrived. The determination of from which quantumelement and/or signal path a particular pulser 302 _(l) is to process aninbound pulse at a particular time may be predetermined in the pulseprogram description 206 or may be determined based on calculationsperformed by the pulser 302 _(l) and/or others of the pulsers 302 ₀-302_(L−1) during runtime. The control circuitry 502 may then use thisinformation to configure the routing block 506 such that the correctmodification settings are routed to the correct one of the pulsers 302₀-302 _(L−1). For example, when pulse generation circuit 302 _(l) needsto demodulate a pulse signal AI_(l) from quantum element 122 _(k), itwill send a dmod_sclt_(l) signal instructing the pulse operation manager356 to rout the element SF_(k00)=cos(ω_(k)*time_stamp+ϕ_(k)) frommodification settings circuit 504 _(k) to pulser 302 _(l) (asf_dmod_(l)).

In the example implementation shown, the digital signals C₀-C_(K−1)provide information about signal-path-specific modification settings tobe used for each of the signal paths 313 ₀-313 _(K−1). For example, eachsignal C_(k) may comprise a matrix to be multiplied by a matrixrepresentation of a raw outbound pulse CP′_(l) such that the resultingoutput outbound pulse is pre-compensated for errors (e.g., resultingfrom imperfections in mixers, amplifiers, wiring, etc.) introduced asthe outbound pulse propagates along signal path 313 _(k). The result ofthe pre-compensation is that output outbound pulse CP_(l) will have theproper characteristics upon arriving at the quantum processor 218. Thesignals C₀-C_(K−1) may, for example, be calculated by the quantumcontroller 210 itself, by the programming subsystem 202, and/or byexternal calibration equipment and provided via I/O manager 368. Thecalculation of signals may be done as part of a calibration routinewhich may be performed before a quantum algorithm and/or may bedetermined/adapted in real-time as part of a quantum algorithm (e.g., tocompensate for temperature changes during the quantum algorithm).

FIG. 6A shows frequency generation circuitry of the quantum controllerof FIG. 3B. In the example implementation shown, the frequencygeneration circuitry is part of control circuitry 502 of pulseoperations manager circuitry 356. The frequency generation circuitrycomprises K coordinate rotation digital computer (CORDIC) circuits 602₀-602 _(K−1), phase generation circuitry 604, timestamp register 606,and S-Matrix generation circuitry 608.

Each CORDIC circuit 602 _(k) is operable to compute cosine and sine ofits input, θ_(k), thus generating two signals cos(θ_(k)) and sin(θ_(k)).

The phase generation circuitry 604 is operable to generate the CORDICinput parameters θ₀-θ_(k−1) based on: (1) the frequency setting signalsIF₀-IF_(L−1) from the pulsers 302 ₀-302 _(L−1); and (2) the contents,TS, of the timestamp register 606.

The timestamp register 606 comprises circuitry (e.g., a counterincremented on each cycle of the clock signal clk1) operable to trackthe number of cycles of clk1 since a reference point in time (e.g.,power up of the quantum controller 210, start of execution of set ofinstructions of a quantum algorithm by the quantum controller 210,etc.).

In the example shown, the phase generation circuitry 604 setsθ₀=2πf₀(TS)(dt_(clk1)), where f₀ is a frequency determined from thesignal IF₀, TS is the number of clock cycles counted from the referencepoint and dt_(clk1) is the duration of a single clock cycle of clk1.This leads to the CORDIC outputs being a pair of phase-quadraturereference signals, cos(2πf₀(TS)(dt_(clk1))) andsin(2πf₀(TS)(dt_(clk1))), as in the example shown, which are used togenerate the S₀ rotation matrix that rotates at a frequency f₀.

As shown in FIG. 6B, the signal IF_(l) may comprise an update componentand an f_(l) component. In an example implementation, when update_(l) isasserted then the phase generation circuitry updates one of more off₀-f_(K−1) to be the value of f_(l).

The S-matrix generation circuitry 608 is operable to build the matricesS₀-S_(K−1) from the outputs of the CORDIC circuits 602 ₀-602 _(K−1). Inan example implementation, the S-matrix generation circuit 608 isoperable to synchronize changes to the S matrices such that any matrixupdate occurs on a desired cycle of clock clk1 (which may be determinedby the control information IF₀-IF_(L−1)).

With K CORDIC circuits 602 _(k), the frequency generation circuitry isoperable to concurrently generate K S-matrices. In instances that morethan K frequencies are needed over the course of a set of instructions,the phase generation circuit 604 is operable to change the inputparameter θ_(k) of one or more of the CORDIC circuits 602 ₀-602 _(K−1)to stop generating one frequency and start generating the K+1^(th)frequency. In some instances, it may be necessary for the new frequencyto start at a phase θ that would have been the phase if the newfrequency was being generated from the initial reference time (e.g.,because the new frequency would be used to address a quantum elementthat has a resonance at the new frequency and that was coherent sincethe reference point). In some other instances, it might be necessary tostart the new frequency from the phase that the old frequency ended in.The phase generation circuit 604 and timestamp register 606 enable bothof these possibilities.

FIG. 7 shows an example implementation of the digital manager of FIG.3B. Shown in FIG. 7 are the digital manager 376, controlled circuits 710₀-710 _(J−1), and input manager 372.

The example implementation of the digital manager 376 comprises inputrouting circuit 702, configuration circuit 704, output routing circuit706, processing paths 708 ₀-708 _(Z−1) (where Z is an integer), androuting control circuit 712.

The configuration circuit 704 is operable to store configurationsettings and use those settings to configure the processing paths 708₀-708 _(Z−1) and/or the routing control circuit 712. The settings may,for example, be loaded via the signal DM_config as part of the pulseprogram description 206 provided by quantum programming subsystem 202.The settings may comprise, for example, one or more of: a bitmap onwhich may be based a determination of which of signals D₀-D_(L−1) toroute to which of signals P′₀-P′_(Z−1) for one or more instructions of apulse program; a bitmap on which may be based a determination of whichprocessing path outputs P₀-P_(Z−1) to route to which ofDigOut₀-DigOut_(J+M−1) for one or more instructions of a pulse program;and one or more bit patterns which processing paths 708 ₀-708 _(Z−1) mayconvolve with one or more of the signals P′₀-P′_(Z−l) for one or moreinstructions of a pulse program.

The input routing circuit 702 is operable to route each of the digitalsignals D₀-D_(L−1) to one or more of the processing paths 708 ₀-708_(Z−1). At any given time (e.g., for any particular instruction of everypulser 302 _(l) of pulsers 302 ₀-302 _(L)), the input routing circuit702 may determine to which of the processing paths 708 ₀-708 _(Z−1) torout the signal D_(l) of signals D₀-D_(L−1) based on the signalfanin_(l) of signals fanin₀-fanin_(L−1). That is, for a particularinstruction, the digital signal D_(l) may be routed to any one or moreof paths 708 ₀-708 _(Z−1) based on the value of fanin_(l) for thatinstruction. For example, fanin_(l) may be a Z-bit signal and a state ofeach bit of fanin_(l) during a particular instruction may indicatewhether Di is to be routed to a corresponding one of the Z processingpaths 708 ₀-708 _(Z−1) during that instruction. An exampleimplementation of the input routing circuit 702 is described below withreference to FIG. 8.

The output routing circuit 706 is operable to route each of the digitalsignals P₀-P_(Z−1) to one or more of DigOut₀-DigOut_(J+M−1) (In theexample shown DigOut₀-DigOut_(J+M−1) connect to stream₀-stream_(M−1),respectively, and DigOut_(M)-DigOut_(J+M−1) connect toDigCtrl0-DigCtrJ−1, respectively). At any given time (e.g., for anyparticular instruction of every pulser 302 _(l) of pulsers 302 ₀-302_(L)), the output routing circuit 706 may determine to which ofDigOut₀-DigOut_(J+M−1) to rout the signal P_(l) of the signalsP₀-P_(L−1) based on the signal fanout_(l) of signalsfanout₀-fanout_(Z−1). That is, for a particular instruction, the digitalsignal P_(z) (z an integer between 0 and Z) may be routed to any one ormore of DigOut₀-DigOut_(J+M−1) based on the value of fanout_(z) for thatinstruction. For example, values of fanout_(z) may be (J+M−1) bits and astate of each bit of fanout_(z) during a particular instruction mayindicate whether P_(z) is to be routed to a corresponding one of theJ+M−1 signals DigOut during that instruction. An example implementationof the output routing circuit 706 is described below with reference toFIG. 8.

Each of the processing path circuits 708 ₀-708 _(Z−1) is operable tomanipulate a respective one of signals P′₀-P′_(Z−1) to generate acorresponding manipulated signal P₀-P_(Z−1). The manipulation maycomprise, for example, introducing a delay to the signal such that theresulting one or more of DigOut₀-DigOut_(J+M−1) reach(es) its/theirdestination (a controlled circuit 710 and/or input manager 372) at theproper time with respect to the time of arrival of a correspondingquantum control pulse at the corresponding destination.

Each of the controlled circuits 710 ₀-710 _(J−1) and input manager 372is a circuit which, at least some of the time, needs to operatesynchronously with quantum control pulses generated by one or more ofpulsers 302 ₀-302 _(L−1) (possibly a reflection/return pulse from aquantum processor in the case of input manager 372). Accordingly, eachof the control circuits 710 ₀-710 _(J−1) receives a respective one ofcontrol signals DigOut₀-DigCtrl_(J−1) that is synchronized with arespective quantum control pulse. Similarly, input manager 372 receivesa plurality of the DigOut signals (one for each stream input).

The routing controller 712 comprises circuitry operable to generatesignals fanin₀-fanin_(L−1) and fanout₀-fanout_(Z−1) based onD_path₀-D_path_(L−1), D_port₀-D_port_(L−1), and/or information stored inconfiguration circuit 704.

FIG. 8 shows an example implementation of the digital manager of FIG.3B. The example input routing circuit 502 comprises routing circuits 802₀-802 _(L−1) and combining circuits 804 ₀-804 _(L−1). The example outputrouting circuitry 506 comprises circuits routing circuits 808 ₀-808_(Z−1) and combining circuits 810 ₀-810 _(J−1). The example processingpath circuits are convolution circuits 806 ₀-806 _(Z−1).

Each of the routing circuits 802 ₀-802 _(L) is operable to route arespective one of signals D₀-D_(L−1) to one or more of the combiningcircuits 804 ₀-804 _(Z−1). To which of combining circuit(s) 804 ₀-804_(Z−1) the signal D_(l) is routed is determined based on the signalfanin_(l). In an example implementation, each signal fanin_(l) is aZ-bits signal and, for a pulser_(l) instruction, the value of bit z ofthe signal fanin_(l) determines whether the signal D_(l) is to be routedto combining circuit 804 _(z) for that instruction. The value offanin_(l) may be updated on a per-instruction basis.

Each of combining circuits 804 ₀-804 _(L−1) is operable to combine up toL of the signals D₀-D_(L−1) to generate a corresponding one of signalsP₀-P_(Z−1). In an example implementation, the combining comprises OR-ingtogether the values of the up to L signals.

Each of the routing circuits 808 ₀-808 _(Z−1) is operable to route arespective one of signals P′₀-P′_(Z−1) to one or more of the combiningcircuits 810 ₀-810 _(J−1). To which of combining circuit(s) 810 ₀-810_(L−1) the signal P′_(z) is routed is determined based on the signalfanout_(z). In an example implementation, each signal fanout_(z) is a(J+M−1)-bit signal and the value of bit j+m−1 of the signal fanout_(z)determines whether the signal P′_(z) is to be routed to combiningcircuit 804 _(j+m−1). In an example implementation the value offanout_(z) is preconfigured before the runtime of the pulse program,however, in another implementation it may be updated dynamically (e.g.,on a per-instruction basis).

Each combining circuit of combining circuits 810 ₀-810 _(J−1) isoperable to combine up to Z of the signals P′₀-P′_(Z−1) (received viainputs 803 ₀ to 803 _(Z−1)) to generate a corresponding one of signalsDigOut₀-DigOut_(J+M−1). In an example implementation, the combiningcomprises OR-ing together the values of the up to Z signals.

Each convolution circuit 806 _(z) is operable to convolve signal P_(z)with pattern_(z) to generate signal P′_(z). In an exampleimplementation, pattern_(z) is preconfigured before runtime of the pulseprogram, however, in another implementation it may be updateddynamically. pattern_(z) may be determined based on: the destination(s)of signal P_(z) (e.g., to which of controlled circuits 510 and/or inputof input manager 352 Pz is intended); characteristics of thecorresponding quantum control pulse (e.g., any one or more of itsfrequency, phase, amplitude, slope, chirp rate, and/or duration); and/orprocess, temperature, and/or voltage variations.

FIG. 9A illustrates configuration and control of the quantum controllervia the quantum programming subsystem. In FIG. 9A, the quantumcontroller 210 comprises one or more instances of various circuits (suchas the pulser, input manager, output manager, digital manager, pulseoperations manager, and analog front end circuits described above).Connected to the inputs and outputs of the quantum controller 210 may bea plurality of external devices (e.g., oscilloscopes, waveformgenerators, spectrum analyzers, mixers, amplifiers, etc.) and aplurality of quantum elements. As described in further detail below,these physical circuits can be allocated and deallocated independentlyof one another such that the physical resources of the quantumcontroller 210, and the quantum elements and external devices connectedto the quantum controller 210 via the analog and digital inputs andoutputs, can be organized into one or more “quantum machines.”

Also shown in FIG. 9A are a compiler 906 and quantum machines manager908 of the quantum programming subsystem 202.

The compiler 906 comprises circuitry operable to generate a machine codepulse program description 206 based on: (1) a specification 902; (2) apulse generation program 904; and (3) a resources management datastructure from the quantum machines manager 908.

Referring to FIG. 9B, an example implementation of the compiler 906comprises analyzer circuitry 952 and synthesizer circuitry 954. Theanalyzer circuitry 952 is operable to parse the specification 902 andprogram 904 to generate an intermediate code representation (e.g., aparse tree). The synthesizer circuitry 954 is operable to generatemachine code based on the intermediate code representation and theavailable resources indicated by the quantum machines manager 908.

The specification 902 identifies resources of a quantum machine some ofwhich are mapped to physical circuits during an instantiation of aquantum machines (e.g. input and output ports of the quantum controller210), and some of which the compiler attaches to physical circuits ofthe quantum controller 210 during compilation of a Pulse generationProgram 904. The compiler 906 may allocate resources for executing theprogram 904 based on the specification 902, the program 904, and/or theavailable resources indicated by the quantum machines manager 908. As anexample, assume a scenario in which there are five quantum elements inthe specification 902 and the program 904 uses only two of the quantumelements; the number of the pulsers 302 ₀-302 _(L) allocated may dependon the available resources and the specifics of the program 904. In onecase the compiler 906 may allocate a first number (e.g., two) of thepulsers 302 ₀-302 _(L) for interfacing with the two quantum elements andin another case the compiler may allocate a second number (e.g., four)for sending pulses to the two quantum elements. Examples of resourcedefinitions which may be present in specification 902 are describedbelow with reference to FIGS. 10A-C. In an example implementation,Python is used as a “host” language for the specification and thespecification is a Python dictionary. In this example implementation thePython syntax/constructs can thus be leveraged to create thespecification (Python variables, functions, etc.).

The pulse generation program 904 comprises statements that define asequence of operations to be performed by the quantum machine defined inthe specification 902. Such operations typically include the generationof one or more analog pulses to be sent to a controlled element, such asa quantum element. Such operations typically include measuring one ormore return pulses from an element. The pulse generation program is alsoreferred to herein as a QUA program. Functions, syntax, etc. of the QUAprogramming language are described below. In an example implementation,Python is used as a “host” language for the QUA program. This allowsleveraging Python syntax/constructs (Python variables, functions, etc.)to generate the QUA program, but it is still a QUA—not Python—program tobe compiled by the compiler 906 to generate QOP machine code, and to beexecuted on the quantum controller/s 210.

In an example implementation, a QUA program defines the sequence ofstatements for: (1) Generating, shaping and sending pulses to thequantum device; (2) Measuring of pulses returning from the quantumdevice; (3) Performing real-time classical calculations on the measureddata and storing results in classical variables; (4) Performingreal-time classical calculations on classical variables; (5) Controllingthe flow of the program, including branching statements; and (6)Streaming of data from the quantum controller 210 to the quantumprograming system 202 and processing and saving it in the quantumprograming system 202.

In addition to the specification of which pulses are played, a QUAprogram can also specify when they should be played through bothexplicit and implicit statements and dependency constructs. Thus, a QUAprogram can define exactly the timing in which pulses are played, downto the single sample level and single clock cycles of the quantumcontroller 210.

In an example implementation, the pulses syntax defines an implicitpulse dependency, which determines the order of pulse execution. Thedependency can be summarized as follows: (1) Each pulse is playedimmediately, unless dependent on a previous pulse yet to be played; (2)Pulses applied to the same quantum element are dependent on each otheraccording to the order in which they are written in the program Inanother implementation, timing and ordering or pulses may be set forthexplicitly in the QUA program.

Example QUA programming constructs are described below in Table 1.

TABLE 1 QUA programming constructs play(pulse * amp(g₀₀, g₀₁, g₁₀, g₁₁),qe, duration=None, condition=None, break condition=None ) Play a pulseto an element. The pulse will be modified according to the properties ofthe element defined in the specification, and then played to the analogoutput(s) defined in the specification. Parameters: pulse - name of thepulse, as defined in the quantum machine specification. qe - name of thequantum element, as defined in the quantum machine specification.duration - duration of the pulse (″=None″ means default is no explicitduration) g_(ij) - an expression; amp() - matrix definition; condition -if present, the pulse will be played with the condition evaluates totrue (″=None″ means default is no condition); break_condition - ifpresent, the pulser will be stopped when the condition evaluates to true(″=None″ means default is no break_condition); It is possible to scalethe pulse's amplitude dynamically by using the following syntax:play(′pulse_name′ * amp(v), ′element′), where amp(v) = mat(v, 0, 0, v)where v is a variable. Moreover, if the pulse is intended for an elementthat receives a pulse pair and thus is defined with two waveforms, thetwo waveforms, described as a column vector, can be multiplied by amatrix: play(′pulse_name′ * amp([v_00, v_01, v_10, v_11]), ′element′),where v_ij, i,j={0,1}, are variables. Example: >>> with program() asprog: >>> v1 = declare(fixed) >>> assign(v1, 0.3) >>> play(′pulse1′,′qe1′) >>> play(′pulse1′ * amp(0.5), ′qe1′) >>> play(′pulse1′ * amp(v1),′qe1′) >>> play(′pulse1′ * amp([0.9, v1, −v1, 0.9]), ′qe_iq_pair′)wait(duration, *qes) Wait for the given duration on all providedelements. During the wait command the quantum controller 210 will output0.0 to the elements.  Parameters: duration (int | QUA variable of typeint) - time to wait (e.g., in multiples of 4nsec with Range: [4, 2²⁴] insteps of 1). *qes (str | sequence of str) - elements to wait on (theasterix denotes there can be 0 or more) wait_for_trigger(element,pulse_to_play) Wait for an external trigger on the provided element.During the wait command the quantum controller 210 will output 0.0 tothe elements.  Parameters: element (str) - element to wait on.pulse_to_play (str | None) - the name of the pulse to play on theelement while waiting for the external trigger. Must be a constantpulse. Can be None to play nothing while waiting. measure(pulse, qe,Rvar, *outputs) The measure statement allows operating on a quantumelement (which has outputs), by sending a pulse to it, after some timeacquiring the returning signal and processing it in various ways Anelement for which a measurement is applied must have outputs defined inthe quatum machine specification. A measurement may comprise: • playinga pulse to the element (identical to a play statement) • waiting for aduration of time defined as the time_of_flight in the definition of theelement, and then sampling the returning pulse. The analog input to besampled is defined in the definition of the element. • processing thereturned samples using the listed process(es) (if any). The processingcould be, for example, demodulation and integration with specifiedintegration parameters, which may produce a scalar or a vector;filtering by a FIR filter, and/or processing by in a neural network.Parameters pulse - name of the pulse, as defined in the quantum machinespecification. Pulse must have a measurement operation. qe - name of theelement, as defined in the quantum machine specification. The elementmust have outputs. Rvar - a result variable reference, a string, or‘None’. If Rvar is a result variable reference, the raw ADC data will besent to the quantum programing subsystem 202 and processed thereaccording to the result processing section of the QUA program. If Rvaris a string the raw ADC data will be sent to the quantum programmingsubsystem 202 and saved as it is with the default minimal processing. IfRvar is set to None, raw results will not be sent to quantum programmingsubsystem 202 and will not be saved. In one implementation, the rawresults will be saved as long as the digital pulse that is played withpulse is high. outputs - a tuple with the form (processing identifier,params, variable name), where: processing reference defined in thetop-level specification and/or in reserved words of the QUA language andreferred to in the pulse definition. Params parameters passed to theprocessing reference variable name the name of a QUA variable to whichthe processing result is assigned. zero or more output tuples may bedefined. Example: >>> with program() as prog: >> > I =declare(fixed) >>> Q = declare(fixed) >>> >>> # measure by playing′meas_pulse1′ to QE ′rr1′, do not save raw results. >>> # demodulate andintegrate using ′cos_weights′ and store result in I, and also >>> #demodulate and integrate using ′sin_weights′ and store result in Q >>>measure(′meas_pulse1′, ′rr1′, None, (‘int’, ′cos_weights′, I), (‘int’′sin_weights′, Q)) >>> >>> # measure by playing ′meas_pulse2′ to QE′rr1′, save raw results to tag ′samples′. >>> # demodulate and integratedata from ′out1′ port of ′rr1′ using the ′optimized_weights′ integrationparameters >>> # store result in I >>> measure(′meas_pulse2′, ′rr1′,′samples′, (‘int’, ′optimized_weights′, ′out1′, I)) align(*qes) Alignseveral quantum elements together. All of the quantum elementsreferenced in *qes will wait for all the others to finish theircurrently running statement. Parameters • *qes (str | sequence of str) -a single quantum element, or list of quantum elements pause() Pause theexecution of the job until QmJob.resume() is called. The quantummachines freezes on its current output state. declare(t) Declare a QUAvariable to be used in subsequent expressions and assignments.Declaration is performed by declaring a python variable with the returnvalue of this function. Parameters • t - The type of QUA variable.Possible values: int, fixed, bool, where: int a signed 32-bit numberfixed a signed 4.28 fixed point number bool either True or False ReturnsThe variable Example: >>> a = declare(fixed) >>> play(′pulse′ * amp(a),′qe′) assign(var, _exp) Set the value of a given QUA variable.Parameters • var (QUA variable) - The variable to set (defined by thedeclare function) • _exp (QUA expression) - An expression to set thevariable to Example: >>> with program() as prog: >>> v1 =declare(fixed) >>> assign(v1, 1.3) >>> play(′pulse1′ * amp(v1), ′qe1′)save(var, tag) Save a QUA variable with a given tag. The tag will appearlater as a field in the saved results object returned byQmJob.get_results(). The type of the variable determines the pythontype, according to the following rule: • int -> int • fixed -> float •bool -> bool Parameters • var (QUA variable) - A QUA variable to save •tag (str) - A name to save the value under update_frequency(qe,new_frequency) Dynamically update the frequency of the NCO associatedwith a given quantum element. This changes the frequency from the valuedefined in the quantum machine specification. Parameters • qe (str) -The quantum element associated with the NCO whose frequency will bechanged • new_frequency (int) - The new frequency value to set in unitsof Hz. Range: (0 to 5000000) in steps of 1. Example: >>> with program()as prog: >>> update_frequency(″q1″, 4000000) z_rotation(angle, *qes)Shift the phase of the NCO associated with a quantum element by thegiven angle. This is typically used for virtual z-rotations. Equivalentto z_rot() Parameters • angle (float) - The angle to add to the currentphase (in radians) • *qes (str | sequence of str) - A quantum element,or sequence of quantum elements, associated with the NCO whose phasewill be shifted z_rot(angle, *qes) Shift the phase of the NCO associatedwith a quantum element by the given angle. This is typically used forvirtual z-rotations. Equivalent to z_rotation() Parameters • angle(float) - The angle to add to the current phase (in radians) • *qes (str| sequence of str) - A quantum element, or sequence of quantum elements,associated with the NCO whose phase will be shifted set_frame(qes,angle) Set the phase of the frame matrix associated with a quantumelement to the given angle. reset_phase(qes, angle) Set the total phaseof the frequency modulation of a quantum element to zero (both thefrequency modulation matrix and the frame matrix). infinite_loop_()Infinite loop flow control statement in QUA. To be used with a contextmanager. Optimized for zero latency between iterations, provided that nomore than a single quantum element appears in the loop. Note In casemultiple quantum elements need to be used in an infinite loop, it ispossible to add several loops in parallel (see example). Example: >>>with infinite_loop_(): >>> play(′pulse1′, ′qe1′) >>> withinfinite_loop_(): >>> play(′pulse2′, ′qe2′) for(var=None, init=None,cond=None, update=None) For loop flow control statement in QUA. To beused with a context manager. Parameters • var (QUA variable) - QUAvariable used as iteration variable • init (QUA expression) - anexpression which sets the initial value of the iteration variable • cond(QUA expression) - an expression which evaluates to a boolean variable,determines if to continue to next loop iteration • update (QUAexpression) - an expression to add to var with each loop iterationExample: >>> x = declare(fixed) >>> with for(var=x, init=0, cond=x<=1,update=x+0.1): >>> play(′pulse′, ′qe′) if(condition) If flow controlstatement in QUA. To be used with a context manager. The QUA code blockfollowing the statement will be executed only if condition evaluates totrue. Parameters • condition - A boolean expression to evaluateExample: >>> x=declare(int) >>> with if_(x>0): >>> play(′pulse′, ′qe′)else Else flow control statement in QUA. To be used with a contextmanager. Must appear after an if() statement. The QUA code blockfollowing the statement will be executed only if expression in precedingif() statement evaluates to false. Example: >>> x=declare(int) >>> withif(x>0): >>> play(′pulse′, ′qe′) >>> with else(): >>>play(′other_pulse′, ′qe′) IO1, IO2 Reserved variables which operate justlike other QUA variables but which refer to dedicated registers/memorylocations in the I/O Manager 368 that can be read from and written to inreal time in a pulse program and via the quantum machine manager API (anexample of which is shown below in Table 6). Example usage in a QUAprogram: >>> pause() >>> play(pulse1*amp(IO1), qubit2)

The Play statement in QUA instructs the quantum controller 210 to sendthe indicated pulse to the indicated element. The quantum controller 210will modify or manipulate the pulse according to the element'sproperties defined in the quantum machine specification (i.e., thecompiler will generate the required pulse modification settings whichwill then be stared to the appropriate one or mare of pulse modificationsettings circuit(s) 504 ₀-504 _(K−1)), so the user is relieved of theburden of having to specify the modifications/manipulations in eachindividual Play statement.

If the element has a single input, the pulse sent to it may be definedwith a single waveform. For example:

‘elements’: {   ‘qubit’: {    ‘SingleInput’: {     ‘port’: (‘con1’, 1),   },    ‘intermediate_frequency’: 70e6,    ‘operations’: {    ‘pulse1’: ‘pulse1’    },   }, } ‘pulses’: {   ‘gauss_pulse_in’: {   ‘operation’: ‘control’,    ‘length’: 12,    ‘waveforms’: {    ‘single’: ‘wf1’,    },   }  }, ‘waveforms’: {   ‘wf1’: {    ‘type’:‘arbitrary’,      ‘samples’:[0.49, 0.47, 0.44, 0.41, 0.37,      0.32,0.32, 0.37, 0.41, 0.44, 0.47, 0.49]   }, }

Denoting the samples of the waveform as s_(i), the play statementinstructs the quantum controller 210 to modulate the waveform sampleswith the intermediate frequency of the element:

=s _(i) cos(ω_(IF) t+ϕ _(F))

ω_(IF), is the intermediate frequency defined in the quantum machinespecification of the element and ϕ_(F) is the frame phase, initially setto zero (see z_rot statement specifications for information on ϕ_(F))The quantum controller 210 then plays s_(i) to the analog output portdefined in the definition of the element (in the above example, port 1).

If the element has two mixed inputs (i.e. two output ports of thequantum controller 210 are connected to the element via an IQ mixer), inaddition to the intermediate frequency, a mixer and a lo_frequency maybe defined in the quantum machine specification. For example:

  ‘elements’: {  ‘qubit’: {   ‘mixedInputs’: {    ‘I’: (‘con1’, 1),   ‘Q’: (‘con1’, 2),    ‘mixer’: ‘mixer1’,    ‘lo_frequency’: 5.1e9,  },   ‘intermediate_frequency’: 70e6,   ‘operations’: {    ‘pulse1’:‘pulse1’   },  }, },

A pulse that is sent to such element may be defined with two waveforms.For example:

‘pulses’: {   ‘pulse1’: {    ‘operation’: ‘control’,    ‘length’: 12,   ‘waveforms’: {     ‘I’: ‘wf_I’,     ‘Q’: ‘wf_Q’,    },   },  },‘waveforms’: {   ‘wf_I’: {    ‘type’: ‘arbitrary’,    ‘samples’:[0.49,0.47, 0.44, 0.41, 0.37,      0.32, 0.32, 0.37, 0.41, 0.44, 0.47, 0.49]  },   ‘wf_Q’: {    ‘type’: ‘arbitrary’,    ‘samples’: [0.02, 0.03,0.03, 0.04, 0.05,      0.00, 0.05, 0.04, 0.03, 0.03, 0.02, 0.02]   }, }

In addition, a mixer can be defined with a mixer correction matrix thatcorresponds to the intermediate_frequency and the lo_frequency. Forexample:

‘mixers’: {  ‘mixer1’: [   {     ‘intermediate_frequency’: 70e6,    ‘lo_frequency’: 5.1e9,     ‘correction’: [0.9, 0.003, 0.0, 1.05]   }  ],

Denoting the samples of the waveforms by I_(i) and Q_(i) the playstatement instructs the quantum controller 210 to modulate the waveformsamples with the intermediate frequency of the element and to apply themixer correction matrix in the following way:

$\begin{pmatrix} \\

\end{pmatrix} = {\begin{pmatrix}C_{00} & C_{01} \\C_{10} & C_{11}\end{pmatrix}\begin{pmatrix}{\cos\left( {{\omega_{IF}t} + \phi_{F}} \right)} & {- {\sin\left( {{\omega_{IF}t} + \phi_{F}} \right)}} \\{\sin\left( {{\omega_{IF}t} + \phi_{F}} \right)} & {\cos\left( {{\omega_{IF}t} + \phi_{F}} \right)}\end{pmatrix}\begin{pmatrix}I_{i} \\Q_{i}\end{pmatrix}}$

ω_(IF), is the intermediate and the C_(ij)'s are the matrix elements ofthe correction matrix defined in the mixer for the relevantintermediate_frequency and lo_frequency. As mentioned above, ϕ_(F) isthe frame phase, initially set to zero (see z_rot statementspecifications for information on ϕ_(F)). The quantum controller 210then plays I_(i) and Q_(i) to the analog output ports defined in thedefinition of the element (in the above example, port 1 and port 2,respectively).

An element could have digital inputs as well as analog inputs. Eachdigital input of an element may be defined with three properties: port,delay, and buffer. For example:

‘elements’: {  ‘qubit’: {   ‘mixedInputs’: {    ‘I’: (‘con1’, 1),   ‘Q’: (‘con1’, 2),    ‘mixer’: ‘mixer1’,    ‘lo_frequency’: 5.1e9,  },   ‘intermediate_frequency’: 70e6,   ‘digital_inputs’:   ‘digital_input1’:     ‘port’: (cont1, 1)     ‘delay’: 144    ‘buffer’: 8    ‘digital_input2’:     ‘port’: (cont1, 2)     ‘delay’:88     ‘buffer’: 20   ‘operations’: {    ‘pulse1’: ‘pulse1’   },  }, },

For a simple example, a pulse that is played to such quantum elementcould include a single digital marker which points to a single digitalwaveform. For example:

‘pulses’: {   ‘pulse1’: {    ‘operation’: ‘control’,    ‘length’: 40,   ‘waveforms’: {     ‘I’: ‘wf_I’,     ‘Q’: ‘wf_Q’,    },   ‘digital_marker’: ‘digital_waveform_high’   },  },‘digital_waveforms’: {   ‘digital_waveform_high’: {    ‘samples’: [(1,0)]   }, }

The coding of the digital waveform may be a list of the form: [(value,length), (value, length), . . . , (value, length)], where each value iseither 0 or 1 indicating the digital value to be played (digital high orlow). Each length may be an integer (e.g., divisible by 4 in one exampleimplementation) indicating for how many nanoseconds the value should beplayed. A length 0 indicates that the corresponding value is to beplayed for the remaining duration of the pulse. In the example above,the digital waveform is a digital high.

When such pulse is played to the element, via the play or themeasurement command, the digital waveform may be sent to all the digitalinputs of the element. For each digital input, however, the quantumcontroller 210 may: (1) Delay the digital waveform by the delay that isdefined in the definition of the digital input (e.g., given in ns); (2)Convolve the digital waveform with a digital pattern that is high for aduration which is, for example, twice the buffer that is defined in thedefinition of the digital input (e.g., given in ns in a “buffer”); and(3) Play the digital waveform to the digital output of the quantumcontroller 210 that is indicated in the quantum machine specification tobe connected to the digital input. In other implementations, the digitalpattern with which the digital waveform to be convolved may be morecomplex than a simple high value. In one such example, the “buffer”object may comprise “duration” and “pattern” properties.

In the example above a play(pulse1, qubit) command would play: (1) Adigital waveform to digital output 1, which starts 144 ns after theanalog waveforms and which is high for 56 ns (the length of the pulseplus 2×8 ns); and (2) A digital waveform to digital output 2, whichstarts 88 ns after the analog waveforms and which is high for 80 ns (thelength of the pulse plus 2×20 ns).

A measurement can be done for an element that has outputs defined in thequantum machine specification. For example:

‘elements’: {  ‘resonator’: {   ‘mixedInputs’: {    ‘I’: (‘con1’, 3),   ‘Q’: (‘con1’, 4),    ‘mixer’: ‘mixer1’,    ‘lo_frequency’: 7.3e9,  },   ‘intermediate_frequency’: 50e6,   ‘outputs’: {    ‘out1’: :(‘con1’, 1),   },   ‘time_of_flight’: 196,   ‘smearing’: 20,  }, },

As seen in the above example, when a quantum element has outputs, twoadditional properties may be defined: time_of_flight and smearing. Thepulse used in a measurement statement may also be defined as ameasurement pulse and may have integration_weights defined. For example:

‘pulses’: {  ‘pulse1’: {   ‘operation’: ‘measurement’,   ‘length’: 400,  ‘waveforms’: {    ‘I’: ‘meas_wf_I’,    ‘Q’: ‘meas_wf_Q’,   },  ‘integration_weights’: {    ‘integ1’: ‘integW1’,    ‘integ2’:‘integW2’,   } ‘integration_weights’: {  ‘integW1’: {   ‘cosine’: [0.0,0.5, 1.0, 1.0, ..., 1.0, 0.5, 0.0]   ‘sine’: [0.0, 0.0, ..., 0.0]  }, ‘integW2’: {   ‘cosine’: [0.0, 0.0, ..., 0.0]   ‘sine’: [0.0, 0.5, 1.0,1.0, ...,1.0, 0.5, 0.0]  }, }

A measurement statement, such as the one shown above, instructs thequantum controller 210 to: (1) Send the indicated pulse to the indicatedelement, manipulating the waveforms in the same manner that is describedin the play statement section above; (2) After a time periodtime_of_flight (e.g., given in ns), samples the returning pulse at thequantum controller 210 input port/s that is/are connected to theoutput/s of the element. It saves the sampled data under stream_name(unless stream_name=None, in which case the sampled data will not besaved). The sampling time window will be of a duration that is theduration of the pulse plus twice the smearing (e.g., given in ns). Thisaccounts for the returning pulse that is longer than the sent pulse dueto the response of the quantum device, as well as for the cables andother elements in the pulse's path; and (3) Process the sampled dataaccording to the parameters specified in the measure statement.

An example of processing the sampled data according to a measurestatement is demodulation of the sampled data with a frequencyintermediate_frequency, defined in the definition of the element,weighted integration of the demodulated data with integration parameters(“integration_weights”) that are defined in the quantum machinespecification and are specified in the measure statement, and storing ofthe result in the indicated variable. The quantum controller 210 canperform multiple (e.g., 10 or more) demodulations and integrations atany given point in time, which may or may not be a part of the samemeasurement statement. The precise mathematical operation on the sampleddata is:

${variable} = {\sum\limits_{i}{s_{i}\left\lbrack {{w_{c}^{i}{\cos\left( {{\omega_{IF}t_{i}} + \phi_{F}} \right)}} + {w_{s}^{i}{\sin\left( {{\omega_{IF}t_{i}} + \phi_{F}} \right)}}} \right\rbrack}}$

where s_(i) is the sampled data, ω_(IF) is the intermediate_frequency,ϕ_(F) is the frame phase discussed in the z_rot statement below, andw_(c) ^(i) and w_(s) ^(i) are the cosine and sine integration_weights.In an example implementation, the integration_weights are defined in atime resolution of 4 ns, while the sampling is done with time resolutionof 1 ns (1 GSa/Sec sampling rate):

w _(c/s) ^(4i) +w _(c/s) ^(4i+1) +w _(c/s) ^(4i+2) +w _(c/s) ^(4i+3)

In the above example, the integration parameters consist of a vector ofintegration weights (which may be a vector with single integrationweight to be used as a constant integration weight) and the receivedsamples of the measurement pulse are integrated to generate a scalarresult. In another implementation, the integration parameters maycomprise an integration weights vector and other parameters to be usedfor specifying how to perform a series of integrations to generate avector of integration results rather than a scalar. For simplicity, thefollowing examples use integrations that results in two-element vectors,but other implementations may generate vectors with three or moreelements.

For example, the integration parameters may specify a first set ofintegration weights to be used for a first plurality of samples of thereceived measurement pulse (e.g., a first 100 ns of the pulse), and asecond set of integration weights to be used for a second plurality ofsamples of the received measurement pulse (e.g., a second 100 ns of thepulse). The parameters may also indicate whether the integration of eachportion should start from zero (referred to here as “chunkedintegration”) or accumulated with the result from the previous portion(referred to here as “accumulated” integration).

Another option is the integration parameters may indicate theintegration is to generate a moving average. The integration parametersmay specify a length an offset of integration windows on which chunkedintegration is to be performed using those windows. For example, theparameters may specify 100 ns windows offset by 40 ns and then chunkedintegration may be performed on samples of the measurement pulse from 0to 100 ns, from 40 ns to 140 ns, from Sons to 180 ns, and so on for theduration of the pulse.

Another example of processing the sampled data according to a measurestatement is processing of the data by a neural network with parametersdefined in the quantum machine specification and/or specified in themeasure statement and storing of the result in the indicated variablewhich can be a scalar or a vector.

Another example of processing the sampled data according to a measurestatement is when the element's output is a digital output and thus thesampled data is digital. One example processing of this data can becounting of the number of digital pulses that arrive to the relevantcontroller's input in a given time window. Another example may be thetime tagging of the arrival of pulses that arrive in a given time windowrelative to the beginning of the window.

Compilation may include allocating specific resources of the quantumcontroller 210 to that quantum machine and then generating machine codethat, when executed by quantum controller 210, will use those allocatedresources.

The quantum machines manager 908 comprises circuitry operable todetermine resources present in the quantum controller 210 and theavailability of those resources at any given time. To determine theresources, the quantum machines manager 908 may be operable to read oneor more configuration registers of the quantum controller 210, inspect anetlist of one or more circuits of the quantum controller 210, and/orparse hardware description language (HDL) source code used to definecircuits of the quantum controller 210 and/or other files used todescribe various configurations of the hardware and software components.Once the resources are determined, the quantum machines manager 908 maykeep track of which resources are in use and which are available basedon which quantum machines are “open” (i.e., in a state where someresources are reserved for that machine regardless of which, if any,pulse program that quantum machine is executing at that time), and/orwhich pulse programs are loaded into and/or being executed by thequantum controller 210 at that time. For example, referring briefly toFIG. 13A, during a time period where two quantum machines are open, eachexecuting one of a first two pulse programs (“Program 1” and “Program2”), the system may be configured as shown in FIG. 13A and a datastructure managed by the quantum machines manager 908 may reflect thesituation as shown in Table 2.

TABLE 2 Example data structure maintained by quantum machines managerResource Status Resource Status Pulsar 1 Allocated to program 2 Port 3Allocated to QM2 Pulsar 2 Allocated to program 2 Port 4 Allocated to QM1Pulsar 3 Allocated to program 1 Port 5 Allocated to QM1 Pulsar 4Available Port 6 Allocated to QM2 Port 1 Allocated to QM2 Port 7Allocated to QM1 Port 2 Available Port 8 Allocated to QM1

During another time period where a single quantum machine is open andexecuting a third pulse program (“Program 3”), the system may beconfigured as shown in FIG. 13B. The data structure managed by thequantum machines manager 908 may reflect the situation as shown in Table3.

TABLE 3 Example data structure maintained by quantum machines managerResource Status Resource Status Pulsar 1 Allocated to Port 3 Allocatedto QM3 program 3 Pulsar 2 Allocated to Port 4 Allocated to QM3 program 3Pulsar 3 Allocated to Port 5 Allocated to QM3 program 3 Pulsar 4Allocated to Port 6 Allocated to QM3 program 3 Port 1 Allocated to QM3Port 7 Allocated to QM3 Port 2 Allocated to QM3 Port 8 Allocated to QM3

Table 4 below shows an example schema which uses Python as a hostlanguage the quantum machine specification is one or more Pythondictionaries.

TABLE 4 Example quantum machine specification schema version integer<int32>  schema version. controllers  object  A collection ofcontrollers. Each controller represents a control  and computationresource on the quantum controller 210  hardware.  property name* object (controller)  specification of a single quantum control module.Here we  define its static properties.   analog_outputs  object  acollection of analog output ports and the properties  associated withthem    property name*  object (quantum control module analog outputport)  specification of the properties of a physical analog output port of the quantum control module.     offset  number  DC offset to output,range: (−0.5, 0.5). Will be applied only  when program runs.  digital_outputs  object    property name*  object (quantum controlmodule digital port)  specification of the properties of a physicaldigital output port  of the quantum control module.     offset  number  analog  object  a collection of analog output ports and the properties associated with them.    Property name*  object (quantum control moduleanalog output port)  specification of the properties of a physicalanalog output port  of the quantum control module.     offset  number DC offset to output, range: (−0.5, 0.5). Will be applied only  whenprogram runs.   type  string  Default: ″opx1″   analog_inputs  object   Property name*  object (quantum control module analog input port) specification of the properties of a physical digital input port of the quantum control module.     Offset  number elements  object  Acollection of quantum elements and/or external devices.  Each quantumelement represents and describes a controlled  entity which is connectedto the ports (analog input, analog  output and digital outputs) of thequantum control module.  property_name*  object (quantum element (QE)) specification of a single element. Here we define to which port  of thequantum control module the element is connected,  what is the RFfrequency of the pulses sent and/or received  from this element  frequency  integer <int32>  resonance frequency [Hz]. Actual carrierfrequency output by  the quantum control module to the input of this QEis  frequency - lo_frequency.   mixInputs  object (mixer input) specification of the input of a QE which is driven by an IQ  mixer    I string  (tuple) of the form ((string) controller name, (int) controller output/input port)    Q  string  (tuple) of the form ((string)controller name, (int) controller  output/input port)    mixer  string the mixer used to drive the input of the QE, taken from the  names inmixers entry in the main quantum machine  specification    lo_frequency integer <int32>  the frequency of the local oscillator which drives themixer   outputs  object  collection of up to two output ports of QE.Keys: “out1” and  ″out2″.    property_name*  string  (tuple) of the form((string) controller name, (int) controller  output/input port)  intermediate_frequency  integer <int32>  intermediate frequency [Hz].The actual frequency to be output  by the quantum control module to theinput of this element   measurement_qe  String  A reference to anelement that has outputs (and thus can be  measured using themeasurement command). This can be  specified for any element that doesnot have outputs so that  whenever a measurement command is used tomeasure this  elements, the actual measurement will be of the referenced element.   smearing  integer <int32>  padding time, in nsec, to add toboth the start and end of the  raw data streaming window during ameasure command.   time_of_flight  integer <int32>  delay time [nsec]from start of pulse until output of QE reaches  quantum control module.Minimal value: 180. Used in measure  command, to determine the delaybetween the start of a  measurement pulse and the beginning of thedemodulation  and/or raw data streaming window.   singleInput  object(single input)  specification of the input of a QE which has a singleinput port    port  string  (tuple) of the form ((string) controllername, (int) controller  output/input port)   operations  object  Acollection of all pulse names to be used in play and measure  commands   property_name*  string  the name of the pulse as it appears under the″pulses″ entry in  the quantum machine specification   digitalInputs object    property_name*  object (digital input)  specification of thedigital input of a QE     port  string  (tuple) of the form ((string)controller name, (int) controller  output/input port)     delay  integer<int32>  the digital pulses played to this QE will be delayed by this amount [nsec] relative to the analog pulses.  An intinsic negativedelay of 143+−2nsec exists by default     output  string  (tuple) of theform ((string) controller name, (int) controller  output/input port)    buffer  integer <int32>  all digital pulses played to this QE willbe convolved with a  digital pulse of value 1 with this length [nsec]pulses  object  A collection of pulses to be played to the quantumelements.  In the case of a measurement pulse, the properties related to the measurement are specified as well.  property_name*  object (pulse) specification of a single pulse. Here we define its analog and  digitalcomponents, as well as properties related to  measurement associatedwith it.   integration_weights  object  if measurement pulse, acollection of integration weights  associated with this pulse,  to beapplied to the data output from the QE and sent to the  controller. Keys: name of integration weights to be used in the  measurementcommand.    property_name*  string  the name of the integration weightsas it appears under the  ″integration_weigths″ entry in the quantummachine  specification   waveforms  object  a specification of theanalog waveform to be played with this  pulse.  If associated elementhas singleInput, key is ″single″.  If associated element has″mixInputs″, keys are ″I″ and ″Q″.    property_name*  string  name ofwaveform to be played at the input port given in  associated keys  digital_marker  string  name of the digital marker to be played withthis pulse   operation  string  type of operation. Possible values:control, measurement   length  integer <int32>  length of pulse [nsec].Possible values: 16 to 4194304 in steps  of 4 waveforms  object  Acollection of analog waveforms to be output when a pulse is  played.Here we specify their defining type (constant, arbitrary  or compressed)and their actual datapoints.  property_name  arbitrary waveform (object)or constant waveform (object) or  compressed waveform (object)   type ‘arbitrary’ | ‘constant’ | ‘compressed’   samples  If type =‘arbitrary’:   Array of numbers <float>   list of values of arbitrarywaveforms, range: (−0.5, 0.5)  If type = ‘constant’:   number <float>  value of constant, range: (−0.5, 0.5)  If type = ‘compressed’:   Arrayof numbers <float>   Integer <int32> digital_waveforms  object  Acollection of digital waveforms to be output when a pulse is  played.Here we specify their actual datapoints.  property_name*  object(digital waveform)  raw data samples of a digital waveform   samples Array of strings  (list of tuples) specifying the analog data accordingto following  code:  The first entry of each tuple is 0 or 1 andcorresponds to the  digital value, and the second entry is the length innsec to play  the value, in steps of 1. If value is 0, the value will beplayed to  end of pulse. integration_weights  object  A collection ofintegration weight vectors used in the  demodulation of pulses returnedfrom a quantum element.  property_name*  object (integration weights) specification of a set of measurement integration weights.  Result ofintegration will be:  sum over i of (W_cosine[i]cos[wt[i]] + W_sine[i]sin[wt[i]])analog[i].  Here:  w is the angular frequency ofthe quantum element, and  analog[i] is the analog data acquired by thecontroller.  W_cosine, W_sine are the vectors associated with the′cosine′  and ′sine′ keys, respectively.  Note: the entries in thevector are specified in 4nsec intervals,  and each entry is repeatedfour times during the  demodulation.  Example:  W_cosine = [2.0], W_sine= [0.0] will lead to the following  demodulation operation: 2.0(cos[wt[0]]analog[0] + cos[wt[1]]analog[1] + [cos][wt[2]]analog[2] + cos[wt[3]]analog[3])   sine  Array of numbers<float>  W_sine, a fixed-point vector of integration weights,  range:[−2048, 2048] in steps of 2**−15   cosine  Array of numbers <float> W_cosine, a fixed-point vector of integration weights,  range: range:[−2048, 2048] in steps of 2**−15 mixers  object  A collection of IQmixer calibration properties, used to post-  shape the pulse tocompensate for imperfections in the mixers  used for upconverting theanalog waveforms.  property_name*  Array of objects (mixer)  intermediate_frequency  integer <int32>  intermediate frequencyassociated with correction matrix   lo_freq  integer <int32>  localoscillator (LO) frequency associated with correction  matrix  correction  string  (tuple) a 2×2 matrix entered as a four-elementtuple specifying  the correction matrix

Elements of the quantum processor, (e.g. qubits, resonators, flux lines,gates, etc.), external devices (e.g., oscilloscopes, spectrum analyzers,waveform generators, etc.), and/or any other element which is a part ofa quantum machine and is connected to output and/or input ports of thecontroller 210, are defined using one or more of the other propertiesdescribed in Table 4 and/or other similar properties which may be usedin other implementations.

An example of other properties which may be used to specify an elementare properties of a neural network that processes pulses sent to theelement. For example, an element specification may specify that pulsessent to it are to be generates and/or processed by a neural network andthe element definition may include one or more parameters specifying thenumber of layers of the neural network, the number of neurons of theneural network, the weights and biases for each neuron of the neuralnetwork, and/or other parameters familiar to those working with neuralnetworks. The neural network having the specified parameters may then betrained during a calibration routine (e.g., at the beginning ofexecution of a QUA program).

For each element defined in a specification 902, the controller outputand/or input ports to which it is connected are defined. Duringcompilation, pulse modification settings for manipulating pulsesintended for an element may be generated (for loading into pulsemodification settings circuits 504) and the pulse modification settingcircuit(s) 504 to which they will be loaded before execution may bechosen and may be allocated to the quantum machine on which the programis to be executed. Similarly, parameters and configurations ofoperations that will be performed on input signals related to an element(e.g. readout/measurement pulses) may be generated during compilation(for loading into compute and signal processing circuits 410). Likewise,the compute and signal processing circuit 410 in which they will be usedmay be chosen during compilation and may be allocated to the quantummachine on which the program is to be executed during compilation.

One example of an element that a quantum machine may contain is an IQmixer that is connected to two output ports of the controller 210. Tocorrect for mixer imbalances, the in-phase/quadrature (IQ) waveforms ofthe pulse can be multiplied by a 2×2 mixer correction matrix beforebeing sent to the output ports. This mixer correction matrix, determinedvia a calibration routine, may be frequency dependent. Thus, a mixerdefinition may include the mixer's name and a list of one or morefrequencies and the correction matrix to be used at each frequency. Inone example implementation, the correction matrix is loaded intocorresponding pulse modification circuit during compilation. Similarly,an element definition may include an intermediate frequency with whichevery pulse sent to the element is to be modulated.

An example quantum machine specification file is described below withreference to FIGS. 10A-10C. While the example implementations we showhere (including the one Table 4 refers to) show some possible propertiesthat can be defined and specified in the quantum machine specification,it is not limited to these examples. For example, various filters andtheir parameters may be defined (e.g. FIR filter) to be performed onpulses to be played to certain elements and/or on input signals to thecontroller.

Pulses available for transmission by a quantum machine may be definedusing one or more of the properties described in Table 4 and/or othersimilar properties which may be used in other implementations. Eachpulse has a length. Each pulse is made of one or more waveforms. In oneimplementation there are two types of pulses: control pulses that arepulses that are only sent to the quantum system and will not bemeasured, and measurement pulses that are sent to the quantum system andwill be measured upon return. The definition of a measurement pulse mayspecify parameters to be used for processing the measurement pulse uponits return from the element to which it was sent. Such parameters mayinclude, for example, integration weights, integration method (e.g.,normal, chunked, accumulated, moving average, etc.), parameters (e.g.,number of layers, number of neurons, weights and biases, and/or thelike) of a neural network, parameters (e.g., number of taps and tapcoefficients) of a FIR filter, and/or the like. During compilation,pulse definitions may be used to, for example: generate pulse templatesto load into pulse template memory 404; generate instructions to beloaded into instruction memory 402 and/or compute and signal processingcircuit 410 for retrieving and manipulating the contents of pulsetemplate memory 404 to achieve the defined pulses; and/or generate oneor more classical processor programs to be executed by compute andsignal processing circuit 410 for processing readout/measurement pulses.

FIGS. 10A-10C show an example quantum machine specification. The exampleshown uses Python as a host language. The example quantum machinespecification is a Python dictionary with a key of “config” and a valuethat comprises a plurality of nested objects, some of which arekey-value pairs and some of which are nested dictionaries.

The “version” key-value pair which indicates the version of the quantummachine specification schema being used.

The “controllers” object is used to specify the number of modules/unitsthat make up the quantum controller 210 of the quantum machine. Theexample shown specifies just a single quantum control module named“con1”, which is of type “opx1” (different opx types may, for example,indicated different hardware and/or configuration of the hardware). Foreach controller 210, the output and input ports that are used in thequantum machine are specified. For analog outputs and inputs, DC offsetvoltage is specified as well.

The “elements” object is used to specify elements that are connected tooutput and input ports of the controller 210. Such elements may includequantum elements (e.g., qubits, readout resonators, flux lines, etc.),external devices (e.g., test equipment such as oscilloscopes, spectrumanalyzers, signal generators, etc.), and/or any other element connectedto the output and/or input ports of the controller. The example shown inFIG. 10A specifies a qubit named “qubit” and a readout resonator named“RR”. The “qubit” element comprises “mixinputs”, “operations”, and“frequency” objects. The “mixinputs” object comprises “I”, “Q”,“lo_frequency”, and “mixer” objects. The “I” and “Q” objects specify thecorresponding output ports of “con1” to which the inputs of the elementare connected. The “intermediate_frequency” object specifies theintermediate frequency with which pulses sent to the qubit are to bemodulated (e.g., determined from a qubit calibration routine). The“mixer” object refers to mixer object “mixer_quibit,” which is definedlater in the quantum machine specification. The “operations” objectspecifies a “gauss-pulse” which refers to the “gauss_pulse_in” object isdefined later in the quantum machine specification. The “RR” elementcomprises “mixinputs”, “operations”, “outputs”, “frequency”,“time_of_flight”, and “smearing” objects. The “mixinputs” objectcomprises “I”, “Q”, “lo_frequency”, and “mixer” objects. The “I” and “Q”objects specify the corresponding ports of “con1”. The “frequency”object specifies the frequency of the readout_resonator (e.g.,determined from a qubit calibration routine). The “mixer” object refersto mixer object “mixer_res,” which is defined later in the quantummachine specification. The “operations” object specifies a “meas_pulse”which refers to the “meas_pulse_in” object is defined later in thequantum machine specification. The “time_of_flight” and “smearing”objects specify those values for the readout resonator. The “outputs”object specifies an output on the element “out1” and the correspondinginput port of “con1” to which it is connected.

The “Pulses” object is used to specify pulses available for transmissionby the quantum machine. The example shown specifies two pulses:“means_pulse_in” and “gauss_pulse_in.” The “means_pulse_in” object inturn comprises “operation”, “length”, “waveforms”,“integration_weights”, and “digital_marker” objects. The “operation”object specifies it as a “measurement” pulse. The “I” and “Q” objects ofthe “waveforms” object refer to the “exc_wf” and “zero_wf” objects whichare defined later in the quantum machine specification. The“integration_weights” object refers to the integration weights objects“integW1” and “integW2” which are defined later in the specification.The “digital_marker” object refers to the “marker1” object defined laterin the specification.

The “gauss_pulse_in” object comprises “operation”, “length”, and“waveforms” objects. The “operation” object specifies it is a “control”pulse. The “I” and “Q” objects of the “waveforms” object refer to the“gauss_wf” and “zero_wf” objects which are defined later in the quantummachine specification.

The “waveforms” object defines the “zero_wf”, “gauss_wf”, and “exc_wf”objects (“exc_wf” not shown) using “type” and “samples” objects.

The “digital_waveforms” defines the “marker1” object using a “samples”object.

The “integration_weights” object defines the objects “integW1” and“integW2” using “cosine” and “sine” objects.

The “mixers” object defines the “mixer_res” and “mixer_qubit” objectsusing “freq”, “lo_freq”, and “correction” objects.

FIG. 11 is a flaw chart showing an example process for operation of thequantum orchestration platform. The process begins in block 1102 inwhich one or more quantum control modules are connected together to formquantum controller 210 and the quantum controller 210 is connected to aquantum system. In this regard, the quantum controller 210 is modularand extendable enabling use of as many units as desired/necessary forthe quantum algorithm to be performed. Each of the modules may, forexample, comprise one or more of each of the circuits shown in FIG. 3B.

In block 1103, a quantum machine with a certain specification isinstantiated by a user. This may be done via a Quantum Machines ManagerAPI. In an example of such an API, shown in Table 5, this may include acall to the open_qm( ) function or the open_qm_from_file( ) function.

TABLE 5 Quantum Machines Manager API Class QuantumMachinesManager(host=None, port=None, **kargs)  close_all_quantum_machines( )   ClosesALL open quantum machines  get_controllers( )   Returns a list of allthe quantum control modules that are available  get_qm(machine_id)  Gets an open quantum machine object with the given machine id  Parameters    machine_id - The id of the open quantum machine to get  Returns    A quantum machine obj that can be used to execute programs list_open_quantum_machines( )   Return a list of open quantum machines.(Returns only the ids, use   get_qm(...) to get the machine object)  Returns   The ids list  open_qm(config, close_other_machines=True) → qm.QuantumMachine.QuantumMachine   Opens a new quantum machine  Parameters   • config - The config that will be used by the namemachine   • close_other_machines - Flag whether to close all     otherrunning machines   Returns    A quantum machine obj that can be used toexecute programs  open_qm_from_file(filename, close_other_machines=True)  Opens a new quantum machine with config taken from a file   on thelocal file system   Parameters   • filename - The path to the file thatcontains the config   • close_other_machines - Flag whether to close all    other running machines   Returns    A quantum machine obj that canbe used to execute programs  perform_healthcheck(strict=True)   Performa health check against the QM programming subsystem.   Parameters   strict - Will raise an exception if health check failed  version( )  Returns    The QM programming subsystem version

In block 1104, the quantum machines manager 908 attempts to allocatemachine resources (i.e., resources allocated to a particular quantummachine regardless of whether a pulse program is currently executing onthat quantum machine) of the quantum controller 210 to the new quantummachine according to the specification.

In block 1105, the quantum machines manager 908 determines whether theallocation and instantiation is successful. If not, then in block 1122an alert is generated for the user (e.g., to inform the user that thereare currently insufficient resources available to instantiate therequired quantum machine), If allocation is successful, then in block1106 the allocated resources are stored in quantum machines manager 908,which updates its data structure of available resources to reflect theallocation of resources to the quantum machine, the new quantum machineis instantiated, and the process advances to block 1107.

In block 1107, a user requests to execute a QUA program on the quantummachine. This may be done via a Quantum Machine API. In an example ofsuch an API, shown in Table 6, this may include a call to the execute( )function. Prior to the request to execute the QUA program, and/or duringthe execution of the QUA program, the user can use a Quantum MachineAPI, such as the one shown below in table 6, to alter any parameter thatwas set in the specification 902. This is advantageous where, forexample, something (e.g., temperature, voltage, equipment in use, and/orany other factor that may impact a quantum experiment), has changedsince the time the specification 902 was generated.

TABLE 6 Quantum Machine API Class QuantumMachine (machine_id, pb_config,config, manager)  close( )  Closes the quantum machine.    Returns   True if the close request succeeded, Raises an exception otherwise. execute(program, duration_limit=1000, data_limit=20000,force_execution=  False, dry_run=False, **kwargs) → qm.QmJob.QmJob  Executes a program and returns a job object to keep track of executionand get results.   Parameters   • program - A program( ) objectgenerated in QUA to execute   • duration_limit (int) - Maximal time (inmsec) for which results will be collected.   • data_limit (int) -   Maximal amount of data sends for which results will be collected.   Here data sends is either:     1. 4 ADC samples, in case raw data istransferred     2. a single save operation   • force_execution (bool) -Execute program even if warnings occur (verify this)   • dry_run(bool) - compile program but do not run it (verify this)   No newresults will be available to the returned job object When duration_limit  is reached, or when data_limit is reached, whichever occurs sooner.  Returns   A QmJob object that can be used to keep track of theexecution and get results  get_config( )    Gives the current config ofthe qm    Returns    A dictionary with the qm's config get_dc_offset_by_qe(qe, input)    get the current DC offset of thequantum control module analog output channel    associated with aquantum element. ** remove ** note: not currently implemented.   Parameters    • qe - the name of the element to get the correctionfor    • input - the input name as appears in the element's config bemore specific here     Returns    the offset, in normalized output units get_digital_buffer(qe, digital_input)    get the buffer for digitalwaveforms of the quantum element    Parameters    • qe (str) - the nameof the element to get the buffer for    • digital_input (str) - thedigital input name as appears in the element's config     Returns    thebuffer  get_digital_delay(qe, digital_input)   Parameters   • qe - thename of the element to get the delay for   • digital_input - the digitalinput name as appears in the element's config    Returns   the delay  get_io1_value( )   Gives the data stored in IO1, which is a reservedvariable that refers to   a first IO register in the I/O manager 368.  No inference is made on type.   Returns   A dictionary with datastored in IO1 . (Data is in all three format: int, float, bool) get_io2_value( )    Gives the data stored in IO2, which is a reservedvariable that refers to    a first IO register in the I/O manager 368   No inference is made on type.    Returns    A dictionary with datafrom the second IO register. (Data is in    all three format: int,float, and bool)  get_io_values( )    Gives the data stored in both IO1and IO2    No inference is made on type.    Returns    A list thatcontains dictionaries with data from the IO registers.    (Data is inall three format: int, float, and bool)  get_smearing(qe)    get thesmearing associated with a measurement quantum element.    This is abroadening of the raw results acquisition window, to account    fordispersive broadening in the measurement elements (readout resonators   etc.) The acquisition window will be broadened by this amount on bothsides.    Parameters    qe (str) - the name of the element to getsmearing for    Returns    the smearing, in nsec. get_time_of_flight(qe)    get the time of flight, associated with ameasurement quantum element.    This is the amount of time between thebeginning of a measurement    pulse applied to quantum element and thetime that the data is    available to the controller for demodulation orstreaming.    Parameters    qe (str) - the name of the element to gettime of flight for    Returns    the time of flight, in nsec list_controllers( )    Gives a list with the defined controllers inthis qm    Returns    The names of the controllers configured in this qm save_config_to_file(filename)    Saves the qm current config to a file   Parameters    filename: The name of the file where the config will besaved  set_correction(qe, values)  Sets the correction matrix forcorrecting gain and phase  imbalances of an IQ mixer associated with aquantum element.  Parameters  • qe (str) - the name of the element toupdate the correction for  • values (tuple) - 4 value tuple whichrepresents the correction matrix  set_dc_offset_by_qe(qe, input, offset)   set the current DC offset of the quantum control module analog   output channel associated with a quantum element.    Parameters    •qe (str) - the name of the element to update the correction for    •input (str) - the input name as appears in the element config. Options:     ‘single’       for an element with single input      ‘I’ or ‘Q’      for an element with mixer inputs    • offset (float) - the dcvalue to set to, in normalized output units.     Ranges from −0.5 to 0.5− 2{circumflex over ( )} −16 in steps of 2{circumflex over ( )} −16. set_digital_buffer(qe, digital_input, buffer)    set the buffer fordigital waveforms of the quantum element    Parameters    • qe (str) -the name of the element to update buffer for    • digital_input (str) -the digital input name as appears in the element's config    • buffer(int) - the buffer value to set to, in nsec. Range: 0 to (255 − delay) /2, in     steps of 1  set_digital_delay(qe, digital_input, delay)   Sets the delay of the digital waveform of the quantum element   Parameters    • qe (str) - the name of the element to update delayfor    • digital_input (str) - the digital input name as appears in theelement's config    • delay (int) - the delay value to set to, in nsec.Range: 0 to 255 − 2 * buffer, in     steps of 1  set_frequency(qe, freq)   Sets the frequency of an element, at the output of the mixer,   taking LO frequency into account.    Parameters    • qe (str) - thename of the element to update the correction for    • freq (float) - thefrequency to set to the given element  set_intermediate_frequency(qe,freq)    Sets the intermediate frequency of the quantum element:   Parameters    • qe (str) - the name of the element to update theintermediate frequency for    • freq (float) - the intermediatefrequency to set to the given element  set_io1_value(value_1)    Setsthe value od IO1.    This can be used later inside a QUA program as aQUA variable IO1 without declaration.    The type of QUA variable isinferred from the python type passed to value_1, according    to thefollowing rule:    int −> int float −> fixed bool −> bool    Parameters   value_1 (float | bool | int) - the value to be placed in IO1 set_io2_value(value_2)    Sets the value of IO1    This can be usedlater inside a QUA program as a QUA variable IO2 without declaration.   The type of QUA variable is inferred from the python type passed tovalue_2, according    to the following rule:    int −> int float −>fixed bool −> bool    Parameters    value_1 (float | bool | int) - thevalue to be placed in IO1  set_io_values(value_1, value_2)    Sets thevalue of IO1 and IO2    This can be used later inside a QUA program as aQUA variable IO1, IO2 without    declaration. The type of QUA variableis inferred from the python type passed to    value_1, value_2 accordingto the following rule:    int −> int float −> fixed bool −> bool   Parameters    • value_l (float | bool | int) - the value to be placedin IO1    • value_2 (float | bool | int) - the value to be placed in IO2 set_smearing(qe, smearing)    set the smearing associated with ameasurement quantum element.    This is a broadening of the raw resultsacquisition window, to account for dispersive    broadening in themeasurement elements (readout resonators etc.) The acquisition    windowwill be broadened by this amount on both sides.    Parameters    • qe(str) - the name of the element to set smearing for    • smearing(int) - the time, in nsec, to broaden the acquisition window. Range: 0to     (255 − time of flight)/2, in steps of 1.  set_time_of_flight(qe,time_of_flight)    set the time of flight, associated with a measurementquantum element.    This is the amount of time between the beginning ofa measurement pulse applied to    quantum element and the time that thedata is available to the controller for    demodulation or streaming.   This time also accounts for processing delays, which are typically176nsec.    Parameters    • qe (str) - the name of the element to settime of flight for    • time_of_flight (int) - the time of flight toset, in nsec. Range: 0 to 255 − 2 *     smearing, in steps of 4.

In block 1108, compiler 906 receives the quantum machine specificationand the QUA program (e.g., in the form of two plain text files).

In block 1109, compiler 906 attempts to compile the program using thequantum machine specification and the resources of the quantumcontroller 210 that the quantum machines manager 908 indicates areavailable for program execution. During compilation, the compilerdetermines and allocates the program resources of the quantum controller210 that will be used in the program.

In block 1110, the compiler 906 determines whether compilation issuccessful. If not, then in block 1122 an alert is generated for theuser (e.g., to inform the user that there are currently insufficientresources available to execute the program). If compilation issuccessful, then the process advances to block 1112. If compilation issuccessful the compiler outputs the machine code to be loaded to thequantum controller for program execution.

In block 1112, the programming system 202 loads machine code generatedby the compiler 906 based on the program, the quantum machinespecification, and the available resources into quantum controller 210(e.g., via I/O Manager 368).

In block 1114, the programming subsystem 202 determines whether themachine code has been successfully loaded into the quantum controller210. If not, then in block 1122 an alert is generated for the user. Ifthe machine code is successfully loaded, then the process advances toblock 1116.

In block 1116, the program is executed on the quantum controller and thequantum machines manager 908 updates its data structure of availableresources to reflect the allocation of resources to the program.

Either while the program is executing and/or after the program executionis over, the user may change the configuration/specification of thequantum machine. This may be done via a Quantum Machine API, an exampleimplementation of which is shown in Table 6. An example of changing theconfiguration/specification of the quantum machine may be that the useruses the call to the set_frequency(qe, freq) function, which changes thefrequency of the specified element to the specified frequency. Anotherexample is using the quantum machine API to set the value of an IOregister in the I/O Manager 368. For example, the following showswaiting for a QUA program to reach a pause instruction, then IO1 is setto a new value via the quantum machine API, and then the QUA programresumes.

  job = qm.execute(program) while job.isPaused( ) != True  wait(0.1)qm.set_IO1([new value]) job.resume( )

In another example implementation such quantum machines API may includecommands for changing any parameter defined in the specification (e.g.an API command may allow to change the definition of the samples of aspecified waveform, change the parameters of a neural network associatedwith an element or a pulse, etc.) If the specification is changed whilea program is running on the quantum machine, this may include writing toregisters and/or memory of the quantum controller 210 while the programis executing as well as changing the specification in the quantummachines manager. If the specification is changed while no program isrunning of the quantum machine, this may include only changing thespecification in the quantum machines manager. The ability to altercharacteristics of the quantum machine without closing the quantummachine and even during execution of a QUA program on the quantummachine enables, for example, altering the quantum machine based oncalculations performed on the quantum programming subsystem 202. As anexample, during execution of a QUA program, results may be streamed fromthe quantum controller 210 to the quantum programming subsystem 202, thequantum programming subsystem 202 may perform some calculations usingthe results (e.g., resource-intensive calculations not possible ordesirable to perform on the quantum controller 210) and then update thequantum machine based on the calculations. The update may impact thecurrently running QUA program or a successive run of the same QUAprogram or a different QUA program without having to close the quantummachine for reconfiguration (which may be desirable to, for example,avoid having to repeat a calibration).

In block 1118, upon completing execution of the instructions, theprogram ends and the quantum machines manager 908 updates its datastructure to deallocate the program resources that were allocated tothat program and updates the available resources.

In block 1120, the process can advance either back to block 1107 againin which a user a user requests to execute a QUA program on the quantummachine, or to block 1124 in which a user closes the quantum machine. Ifthe user closes the quantum machine the process advances to block 1126.

In block 1126 the quantum machines manager 908 deallocate the machineresources that were allocated to that quantum machine and updates theavailable resources.

In an example implementation, the pulse generation program 904 iswritten using the QUA programming language.

To aid understanding of the QOP's unique approach to quantum control, ause case example of Power Rabi Calibration will now be described,end-to-end. The use case begins by discussing the theoretical backgroundof the experiment and its goals and showing a typical setup on which itis implemented. It is then shown, step by step, how to program the QOPto perform this experiment, how to execute it, and how to retrieve theresults.

The purpose of Power Rabi Calibration is to measure Rabioscillations—oscillations of the qubit state that are driven by acontrol signal. Assume that the qubit is initially in the ground state(state 0), a drive pulse is applied to rotate the qubit on the Blochsphere around a rotation axis in the x-y plane. The qubit is thenmeasured by calculating the effect of the resonator (that is coupled tothe qubit) on a measurement pulse. The rotation angle, and consequentlythe probability to find the qubit in the excited state (1), depends onthe amplitude of the drive pulse. The protocol is repeated with varyingamplitudes (a). For each amplitude, the protocol is repeated many timesfor averaging, which allows extracting the probability of the qubit tobe in the excited state after the drive pulse is applied. Thisprobability is then plotted as a function of the drive amplitude, fromwhich the rotation angle, as a function of the amplitude, can beextracted. This experiment provides an important tool for calibratingquantum gates. For example, the amplitude at which the qubit reaches arotation of 180 degrees gives us the required amplitude for performingan X-gate (the quantum NOT gate). Similarly, this program can be run toidentify the amplitude required to perform a π/2-rotation.

The example experiment setup is shown in FIG. 12A. The quantum device isa superconducting circuit composed of a single, fixed frequency qubitand a readout resonator, with the following Hamiltonian:

$H = {{\frac{\hslash}{2}\omega_{Q}\sigma_{Z}} + {{\hslash\omega}_{R}a^{\dagger}a} + {{{\hslash g}\left( {{a^{\dagger}\sigma^{-}} + {a\;\sigma^{+}}} \right)}.}}$

Since the interaction between the qubit and resonator is dispersive(|ω_(R)−ω_(Q)|), an approximation can be made that leads to thefollowing form of the Hamiltonian:

$H = {{\frac{\hslash}{2}\left( {\omega_{Q} + \frac{g^{2}}{\Delta}} \right)\sigma_{Z}} + {{\hslash\left( {\omega_{R} + {\frac{g^{2}}{\Delta}\sigma_{Z}}} \right)}a^{\dagger}a}}$

Where Δ=ω_(Q)−ω_(R). Finally, the qubit driving term can be explicitlyincluded, which leads to the Hamiltonian:

$H = {H_{0} + {\hslash\;{s(t)}{\sigma_{x}.{+ {\frac{m(t)}{2}\left\lbrack {{a^{\dagger}e^{{- i}\;\omega\; t}} + {ae}^{i\;\omega\; t}} \right\rbrack}}}}}$

Here it is assumed that the frequencies of both the qubit and theresonator were calibrated in advance.

A signal, at the resonance frequency of the qubit, of the form

s(t)=A cos(ω_(Q) t+ϕ)

rotates the Bloch vector of the qubit at a rate A around the axis whichis on the x-y plane and is rotated by an angle φ from the x-axis.

If the parameters A(t) and φ(t) are varied slowly compared to ω_(Q),then this still holds at each point in time. Thus, if a pulse is sent(i.e. a signal that is finite in time) to the qubit of the form

s(t)=A(t)cos(ω_(Q) t+ϕ)

where A(t) varies slowly compared to ω_(Q), the Bloch vector will berotated around the above axis by a total angle which is given by theintegral of A(t):

θ=∫_(t) ₀ ^(t) ⁰ ^(+τ) A(t)dt.

Here t₀ is the time at which the pulse starts and τ is the duration ofthe pulse.

In a typical Power Rabi Oscillations experiment, the shape and durationof the pulse A(t) are fixed (e.g. a 20-nanosecond gaussian pulse) andonly its amplitude is varied in order to get different rotation anglesθ. The experiment performed by repeating the following basic sequence:

(1) Initialize the qubit to the ground state, 0.(2) Apply a pulse with amplitude a (e.g. A(t) is a Gaussian shaped pulsewith peak amplitude a, which rotates the qubit by θ so that the qubit isin the state

cos(θ_(a))|

0+e ^(iϕ) sin(θ_(a))|1

.

(3) Apply a resonant pulse to the readout resonator, and from the phaseof the reflected pulse, deduce the state of the qubit.

This basic sequence is repeated in the program for a series ofamplitudes (i.e., many values of a), where for each amplitude, a, it isrepeated N times (i.e. N identical basic sequences with the same a). Nidentical measurements are required because of state collapse. Themeasurement at the end of each basic sequence gives a binary result (0or 1) for the state of the qubit, even if before the measurement thequbit was in a superposition state. However, when the results of the Nidentical basic sequences are averaged, the average will be ˜sin²(θ).Denote this average as P_(|1)

(a) since it reflects the probability of measuring the qubit in the |1

state for a given amplitude, a. The results of the whole experiment canbe summarized by plotting P_(|1)

(a) as a function of a (see FIG. 12B).

This can be used to calibrate any single qubit rotation gate thatrotates the qubit by an angle θ, around a rotation axis that is on thex-y plane and is rotated φ from the x-axis. Such a gate is denoted byR_(ϕ(θ)). In fact, one of the typical goals of the Power RabiOscillations experiment is to calibrate the amplitude of a given pulseso that it performs π-rotation (X-gate) or π/2-rotation. φ, however,cannot be determined from the Rabi oscillations and must be determinedby other means (e.g. tomography).

An example implementation of the Power Rabi experiment in the QOP willnow be described.

The experiment is implemented on the QOP as follows: (1) Defining aquantum machine specification; (2) Opening an interface to the quantummachine; (3) Writing the program; (4) Running the program; (5) Savingthe results

As discussed above, the quantum machine specification is a descriptionof the physical elements present in the experimental setup and theirproperties, as well as the connectivity between the elements and thequantum control module(s). The physical elements that are connected tothe quantum control module(s) are denoted in the quantum machinespecification as elements, which are discrete entities such as qubits,readout resonators, flux lines, gate electrodes, etc. Each of these hasinputs and in some cases outputs, connected to the quantum controlmodule(s). The properties of the elements and their connectivity to thequantum control module(s) are used by the QOP to interpret and executeQUA programs correctly (e.g. a pulse played to a certain qubit ismodulated by the quantum control module with the intermediate frequencydefined for this element). The quantum machine specification in FIGS.10A-10C is used for this particular example.

The pulses applied to the elements are also specified in the quantummachine specification, where each pulse is defined as a collection oftemporal waveforms. For example, a pulse to an element with two analoginputs and one digital input will specify the two waveforms applied tothe analog inputs of the element and the digital pulse applied to itsdigital input.

Also defined in the quantum machine specification are the properties ofany auxiliary components that affect the actual output of thecontroller, such as IQ mixers and local oscillators.

After defining the quantum machine specification, an interface to a newquantum machine can be opened with the following command:

-   -   my_qm=qmManager.open_qm(my_config)

After having defined the quantum machine specification, write the QUAprogram. Below is the power Rabi program.

-   -   with program( ) as powerRabiProg:

  I = declare(fixed) Q = declare(fixed) a = declare(fixed) Nrep =declare(int) with for_(Nrep, 0, Nrep < 100, Nrep + 1):  with for_(a,0.00, a <= 1.0, a + 0.01):   play(‘gauss_pulse’*amp(a), ‘qubit’)  align(“qubit”, “RR”)   measure(‘meas_pulse’, ‘RR’, ‘samples’,   (‘integW1’,I), (‘integW2’,Q))   save(I, ‘I’)   save(Q, ‘Q’)   save(a,‘a’)

The program is very intuitive to someone who knows the theory of thePower Rabi calibration, which illustrates one of the benefits of theQOP: the ability for people (e.g., quantum physicists) to rapidly designand run quantum experiments without first having to become expertprogrammers or computer systems designers. This is in stark contrast tocurrent systems which, for example, require quantum physicists to learna hardware description language such as VHDL or Verilog to be able torun their quantum experiments/algorithms.

This program: (1) Defines the variables a (amplitude) and Nrep (numberof repetitions), as well as the variables I and Q, which store thedemodulation result; and (2) Performs 100 repetitions (the loop overNrep), where in each scan loops over 100 values of a, from 0-1 inincrements of 0.01 and for each value of a performs the Rabi sequence:playing a pulse with amplitude a to the qubit, then measuring theresonator response and extracting from it the state of the qubit. Thisis done by sending a measurement pulse to the resonator and demodulatingand integrating the returning pulse using the indicated integrationweights.

The raw data sampled at the quantum control module's input is alsostreamed and saved with the label ‘samples.’ Finally, the demodulationand integration results, I and Q, are saved as well as the correspondingamplitude.

This Python code block creates an object named powerRabiProg, which is aQUA program that can be executed on an open quantum machine.

The program is run on a quantum machine “my_qm” defined in the quantummachine specification using the following command which saves theresults in the job object “my_job.”

-   -   myjob=my_qm.execute(powerRabiProg)

After the program is executed, the results can be pulled:

-   -   my_powerRabi_results=job.get_results( )

This command pulls the results from “my_job” to the results object“my_powerRabi_results”.

The data in “my_powerRabi_results” is a Python object which contains thevariables saved during the program, as well as all the raw data sampledat the input of the quantum control module. Here, “my_powerRabi_results”will have: (1) my_powerRabi_results.variable_results, which will be adictionary containing three keys: ‘I’, ‘Q’ and ‘a’. The value for eachkey will be a dictionary containing the saved data and the time stampfor each saved data point; (2) my_powerRabi_results.raw_results, whichwill be a dictionary containing a single key and its value will be adictionary containing the sampled input data and the timestamp of eachdata point.

In accordance with an example implementation of this disclosure, asystem comprises a pulse program compiler circuit (e.g., 906) comprisingcircuitry operable to analyze a pulse program (e.g., 904) that comprisesa pulse operation statement that (e.g., a play or measure statement oftable 1) that specifies a first pulse to be generated, and specifies atarget of the first pulse (e.g., a qubit, antenna, and/or any otherdevice or circuit to or at which pulses are transmitted). The compileris operable to generate, based on the pulse program, machine code that,if loaded into a pulse generation and measurement circuit (e.g., 260),configures the pulse generation and measurement circuit to generate thefirst pulse and send the first pulse to the target. The pulse programmay comprises a first declaration statement that defines a firstvariable, and the pulse operation statement may reference the firstvariable. The first variable may be part of an expression thatdetermines one or more characteristics (e.g., phase, frequency,amplitude, duration, time of generation, and/or the like) of the firstpulse. Loading the machine code into the pulse generation andmeasurement circuit may configure the pulse generation and measurementcircuit to determine (e.g., in a CSP 410) a value to be assigned to thefirst variable during runtime of the machine code. The pulse operationstatement may specify parameters to be used for processing of a returnsignal resulting from transmission of the first pulse (e.g., a returnfrom a readout resonator that was the target of the first pulse or areflection of the first pulse off of a physical object), and loading themachine code into the pulse generation and measurement circuit mayconfigure the pulse generation and measurement circuit to perform theprocessing of the return signal. The processing of the return signal maycomprise integration of the return signal, and the parameters mayspecify integration weights to use for the integration. The integrationweights may be specified as one or more vectors. The parameters maycomprise parameters of a neural network to be used for the processing ofthe return signal. The processing of the return signal may comprisesintegration of the return signal, and the parameters may specify timeparameters to use for the integration (e.g., duration of a window overwhich to perform the integration, a length of an offset of window,and/or the like). The processing of the return signal may comprisedemodulation of the return signal. The parameters may specify thefrequency of a local oscillator to use for the demodulation. The returnsignal may comprise a series of pulses and the processing of the returnsignal may comprise counting the number of pulses in a given timewindow. The return signal may comprises a series of pulses and theprocessing of the return signal may comprise identifying the arrivaltime of each pulse relative to the beginning of a specified time window.The pulse operation statement may specify that a result of processing ofa return signal resulting from transmission of the first pulse is to beassociated with the first variable and stored to memory (e.g., in 260and/or 252), and loading the machine code into the pulse generation andmeasurement circuit may configure the pulse generation and measurementcircuit to associate the result with the first variable and store theresult to memory. The pulse operation statement may specify anexpression to be used for processing of the first pulse by the pulsegeneration and measurement circuit (e.g., in a pulser 302 and/or pulseoperations circuit 358) before the pulse generation and measurementcircuit sends the first pulse to the target. Loading the machine codeinto the pulse generation and measurement circuit may configure thepulse generation and measurement circuit to perform the processing ofthe first pulse before sending the first pulse to the target. The pulseprogram may comprise a first declaration statement that defines a firstvariable. The pulse operation statement may references the firstvariable. The expression may reference the first variable. Loading themachine code into the pulse generation and measurement circuit mayconfigure the pulse generation and measurement circuit to determine thevalue of the first variable during runtime of the machine code. Thepulse operation statement may specify a condition expression that is tobe evaluated during runtime by the pulse generation and measurementcircuit, and that must evaluate to a determined value before the firstpulse is sent to the target. Loading the machine code into the pulsegeneration and measurement circuit may configure the pulse generationand measurement circuit to evaluate the condition expression duringruntime of the machine code, and send the first pulse to the target onlywhen the condition expression evaluates to the determined value. Thepulse program comprises a phase alteration statement that specifies thetarget and an expression for the angle by which to alter a phase of alocal oscillator of the pulse generation and measurement circuit that isassociated with the target. Loading the machine code into the pulsegeneration and measurement circuit may configure the pulse generationand measurement circuit to evaluate the expression during runtime of themachine code, and alter the phase of the local oscillator generationcircuit based on a result of the evaluation of the expression. The pulseprogram may comprises a update frequency statement that specifies thetarget and an expression for the frequency to which to set a localoscillator of the pulse generation and measurement circuit that isassociated with the target. Loading the machine code into the pulsegeneration and measurement circuit may configure the pulse generationand measurement circuit to: evaluate the expression during runtime ofthe machine code; and set the frequency of the local oscillatorgeneration circuit based on a result of the evaluation of theexpression. The pulse program may comprises a flow control statement(e.g., a trigger wait, a wait or wait_for_trigger statement). Thetrigger wait statement is able to stop the program execution until atrigger is received. Such a trigger may be generated by software orhardware. Loading the machine code comprising the flow control statementinto the pulse generation and measurement circuit may configure thepulse generation and measurement circuit to wait for a signal beforeresuming execution of the pulse program. The pulse program comprises aconditional statement (e.g., if statement, loop statement, etc.) thatspecifies a condition expression and one or more conditioned statements.Loading the machine code into the pulse generation and measurementcircuit may configure the pulse generation and measurement circuit to:evaluate the condition expression; and execute instructionscorresponding to the one or more condition statements only if thecondition expression evaluates to a determined value (e.g., true orfalse). The compiler may be operable to parse a machine specification(e.g., 902) that comprises a definition of the first pulse and adefinition of the target; and generate the machine code based on theparsed machine specification. The pulse operation statement mayspecifies a break condition. Loading the machine code into the pulsegeneration and measurement circuit may configure the pulse generationand measurement circuit to: evaluate the break condition expression; andstop generation of the first pulse when the break condition evaluates toa determined value. The pulse program may comprise an align statementthat specifies a plurality of pulse targets. Loading the machine codeinto the pulse generation and measurement circuit may configure thepulse generation and measurement circuit to wait for execution ofinstructions involving any of the plurality of pulse targets to completebefore beginning execution of subsequent instructions involving any ofthe plurality of pulse targets. The pulse program may comprises a waitstatement that specifies a target and an amount of time to wait beforesending a pulse to the target. Loading the machine code into the pulsegeneration and measurement circuit may configures the pulse generationand measurement circuit to wait the specified amount of time. The pulseprogram may comprise a variable assignment statement that assigns anexpression to a variable (e.g., IO1) that is associated with a registerthat can be read from and/or written to by a programming subsystemduring runtime of the machine code, and the pulse operation statementmay references the variable (e.g., as a parameter and/or in anexpression). The pulse program may comprise a variable declarationstatement that assigns a first variable to a second variable, where thesecond variable (e.g., IO1) is a reserved variable reference to aregister that can be read from and/or written to by a programmingsubsystem during runtime of the machine code, and the pulse operationstatement may references the second variable.

The present method and/or system may be realized in hardware, software,or a combination of hardware and software. The present methods and/orsystems may be realized in a centralized fashion in at least onecomputing system, or in a distributed fashion where different elementsare spread across several interconnected computing systems. Any kind ofcomputing system or other apparatus adapted for carrying out the methodsdescribed herein is suited. A typical implementation may comprise one ormore application specific integrated circuit (ASIC), one or more fieldprogrammable gate array (FPGA), and/or one or more processor (e.g., x86,x64, ARM, PIC, and/or any other suitable processor architecture) andassociated supporting circuitry (e.g., storage, DRAM, FLASH, businterface circuits, etc.). Each discrete ASIC, FPGA, Processor, or othercircuit may be referred to as “chip,” and multiple such circuits may bereferred to as a “chipset.” Another implementation may comprise anon-transitory machine-readable (e.g., computer readable) medium (e.g.,FLASH drive, optical disk, magnetic storage disk, or the like) havingstored thereon one or more lines of code that, when executed by amachine, cause the machine to perform processes as described in thisdisclosure. Another implementation may comprise a non-transitorymachine-readable (e.g., computer readable) medium (e.g., FLASH drive,optical disk, magnetic storage disk, or the like) having stored thereonone or more lines of code that, when executed by a machine, cause themachine to be configured (e.g., to load software and/or firmware intoits circuits) to operate as a system described in this disclosure.

As used herein the terms “circuits” and “circuitry” refer to physicalelectronic components (i.e. hardware) and any software and/or firmware(“code”) which may configure the hardware, be executed by the hardware,and or otherwise be associated with the hardware. As used herein, forexample, a particular processor and memory may comprise a first“circuit” when executing a first one or more lines of code and maycomprise a second “circuit” when executing a second one or more lines ofcode. As used herein, “and/or” means any one or more of the items in thelist joined by “and/or”. As an example, “x and/or y” means any elementof the three-element set {(x), (y), (x, y)}. As another example, “x, y,and/or z” means any element of the seven-element set {(x), (y), (z), (x,y), (x, z), (y, z), (x, y, z)}. As used herein, the term “exemplary”means serving as a non-limiting example, instance, or illustration. Asused herein, the terms “e.g.,” and “for example” set off lists of one ormore non-limiting examples, instances, or illustrations. As used herein,circuitry is “operable” to perform a function whenever the circuitrycomprises the necessary hardware and code (if any is necessary) toperform the function, regardless of whether performance of the functionis disabled or not enabled (e.g., by a user-configurable setting,factory trim, etc.). As used herein, the term “based on” means “based atleast in part on.” For example, “x based on y” means that “x” is basedat least in part on “y” (and may also be based on z, for example).

While the present method and/or system has been described with referenceto certain implementations, it will be understood by those skilled inthe art that various changes may be made and equivalents may besubstituted without departing from the scope of the present methodand/or system. In addition, many modifications may be made to adapt aparticular situation or material to the teachings of the presentdisclosure without departing from its scope. Therefore, it is intendedthat the present method and/or system not be limited to the particularimplementations disclosed, but that the present method and/or systemwill include all implementations falling within the scope of theappended claims.

What is claimed is: 1-40. (canceled)
 41. A method comprising: receiving,by a pulse program compiler, a pulse program comprising a pulseoperation statement that specifies a first pulse to be generated, acharacteristic of the first pulse, and a target of the first pulse;generating, by the pulse program compiler, machine code according to thepulse program; loading the machine code into a pulse generation andmeasurement circuit; and configuring the pulse generation andmeasurement circuit, according to the machine code, to generate thefirst pulse and send the first pulse to the target.
 42. The method ofclaim 41, wherein: the pulse program comprises a first declarationstatement that defines a first variable; and the pulse operationstatement references the first variable.
 43. The method of claim 42,wherein the first variable is part of an expression that determines thecharacteristic of the first pulse.
 44. The method of claim 41, whereinthe characteristic is an amplitude of the first pulse.
 45. The method ofclaim 41, wherein the characteristic is a duration of the first pulse.46. The method of claim 43, wherein: configuring the pulse generationand measurement circuit comprises determining a value to be assigned tothe first variable during runtime of the machine code.
 47. The method ofclaim 41, wherein: the pulse operation statement does not specify anintermediate frequency of the first pulse; and generating the machinecode comprises setting the intermediate frequency of the first pulseaccording to the target.
 48. The method of claim 41, wherein: the pulseoperation statement specifies parameters to be used for processing areturn signal resulting from transmission of the first pulse; and themethod comprises configuring the pulse generation and measurementcircuit to process of the return signal.
 49. The method of claim 48,wherein: processing the return signal comprises an integration of thereturn signal; and the parameters specify integration weights to use forthe integration.
 50. The method of claim 49, wherein the integrationweights are specified as one or more vectors.
 51. The method of claim48, wherein the parameters comprise parameters of a neural network to beused for processing the return signal.
 52. The method of claim 48,wherein: processing the return signal comprises an integration of thereturn signal; and the parameters specify time parameters to use for theintegration.
 53. The method of claim 48, wherein: processing the returnsignal comprises a demodulation of the return signal; and the parametersspecify a frequency to use for the demodulation.
 54. The method of claim48, wherein: the return signal comprises a series of pulses; andprocessing the return signal comprises counting a number of pulses in agiven time window.
 55. The method of claim 48, wherein: the returnsignal comprises a series of pulses; and processing the return signalcomprises identifying an arrival time of each pulse relative to abeginning of a specified time window.
 56. The method of claim 41,wherein: the pulse program comprises a first declaration statement thatdefines a first variable; the pulse operation statement references thefirst variable; the pulse operation statement specifies that a result ofprocessing a return signal resulting from transmission of the firstpulse is to be associated with the first variable and stored to memory;and the method comprises associating the result with the first variableand storing the result to memory.
 57. The method of claim 41, wherein:the pulse operation statement specifies an expression to be used forprocessing the first pulse by the pulse generation and measurementcircuit before the pulse generation and measurement circuit sends thefirst pulse to the target; and the method comprises processing the firstpulse before sending the first pulse to the target.
 58. The method ofclaim 57, wherein: the pulse program comprises a first declarationstatement that defines a first variable; the expression references thefirst variable; and the method comprises determining a value of thefirst variable during runtime of the machine code.
 59. The method ofclaim 58, wherein the method comprises: processing a return signal; anddetermining a value of the first variable according to the processing ofthe return signal.
 60. The method of claim 59, wherein the value of thefirst variable is a fixed point or floating point number.
 61. The methodof claim 41, wherein: the pulse operation statement specifies acondition expression that: is to be evaluated during runtime by thepulse generation and measurement circuit, and must be evaluated to adetermined value before the first pulse is sent to the target; and themethod comprises: evaluating the condition expression during runtime ofthe machine code, and sending the first pulse to the target only whenthe condition expression evaluates to the determined value.
 62. Themethod of claim 41, wherein: the pulse program comprises a phasealteration statement that specifies the target and an expression for anangle for altering a phase of a local oscillator associated with thetarget; and the method comprises: evaluating the expression duringruntime of the machine code, and altering the phase of the localoscillator according to a result of the evaluation of the expression.63. The method of claim 41, wherein: the pulse program comprises anupdate frequency statement that specifies the target and an expressionfor the frequency of a local oscillator associated with the target; andthe method comprises: evaluating the expression during runtime of themachine code, and setting the frequency of the local oscillatoraccording to a result of the evaluation of the expression.
 64. Themethod of claim 41, wherein: the pulse program comprises a flow controlstatement; and the method comprises waiting for a signal before resumingexecution of the pulse program.
 65. The method of claim 41, wherein: thepulse program comprises a conditional statement that specifies acondition expression and one or more conditioned statements; and themethod comprises: evaluating the condition expression; and executinginstructions corresponding to the one or more conditioned statementsonly if the condition expression evaluates to a determined value. 66.The method of claim 65, wherein: the conditioned expression comprises avariable; and the method comprises: processing a return signal, anddetermining a value of the variable according to the processing of thereturn signal.
 67. The method of claim 66, wherein the value of thevariable is a fixed point or floating point number.
 68. The method ofclaim 41, wherein: the pulse program comprises a conditional statementthat specifies a condition expression, a first conditioned statement,and a second conditioned statement; and the method comprises: evaluatingthe condition expression; and executing instructions corresponding tothe first conditioned statements only if the condition expressionevaluates to a first value, and executing instructions corresponding tothe second conditioned statement only if the condition expressionevaluates to a second value.
 69. The method of claim 68, wherein thefirst conditioned statement is a second pulse operation statement andthe second conditioned statement is a third pulse operation statement.70. The method of claim 41, wherein the method comprises: parsing amachine specification that comprises a definition of the first pulse anda definition of the target; and generating the machine code according tothe machine specification.
 71. The method of claim 41, wherein: thepulse operation statement specifies a break condition; and the methodcomprises: evaluating the break condition, and stopping generation ofthe first pulse when the break condition evaluates to a determinedvalue.
 72. The method of claim 41, wherein: the pulse program comprisesan align statement that specifies a plurality of pulse targets; and themethod comprises waiting for an execution of instructions involving anyof the plurality of pulse targets to complete before beginning anexecution of subsequent instructions involving any of the plurality ofpulse targets.
 73. The method of claim 41, wherein: the pulse programcomprises a wait statement that specifies a target and an amount of timeto wait before sending a pulse to the target; and the method compriseswaiting the specified amount of time.
 74. The method of claim 41,wherein: the pulse program comprises a variable assignment statementthat assigns an expression to a variable that is associated with aregister that can be read from and/or written to by a programmingsubsystem during runtime of the machine code; the pulse operationstatement references the variable.
 75. The method of claim 41, wherein:the pulse program comprises a variable declaration statement thatassigns a first variable to a second variable, where the second variableis a reserved variable reference to a register that can be read fromand/or written to by a programming subsystem during runtime of themachine code; and the pulse operation statement references the secondvariable.
 76. The method of claim 41, wherein the characteristic is aslope of the first pulse.
 77. The method of claim 41, wherein thecharacteristic is a chirp rate of the first pulse.
 78. The method ofclaim 41, wherein the pulse program comprises a trigger wait statementoperable to stop the program execution until a trigger is received. 79.The method of claim 78, wherein the trigger is generated by software.80. The method of claim 78, wherein the trigger is generated byhardware.